สวัสดีครับ ผมเขียนบทความนี้จากประสบการณ์ตรงในการพัฒนา MCP Tool มากว่า 2 ปี ตอนเริ่มต้น ผมเคยเจอปัญหาว่าเรียก API แล้วได้ Error สีแดงเต็มหน้าจอ แต่ไม่รู้ว่าผิดตรงไหน วันนี้ผมจะสอนทุกคนตั้งแต่ขั้นพื้นฐานจนสามารถ Debug ได้ด้วยตัวเอง

MCP Tool คืออะไร ทำไมต้อง Debug

MCP ย่อมาจาก Model Context Protocol เป็นมาตรฐานการเชื่อมต่อระหว่าง AI กับเครื่องมือภายนอก ลองนึกภาพว่าคุณมีหุ่นยนต์ AI ที่ทำงานได้หลายอย่าง แต่มันต้องมีคนคอยบอกว่าทำถูกหรือผิดตรงไหน การ Debug ก็คือการเป็นคนคอยตรวจสอบและแก้ปัญหาให้หุ่นยนต์นั้นทำงานได้อย่างถูกต้องนั่นเอง

ขั้นตอนที่ 1: ตั้งค่า Log พื้นฐานให้เห็นทุกการทำงาน

ก่อนแก้ปัญหาใดๆ เราต้องเห็นว่าโปรแกรมทำอะไรบ้าง ผมจะสอนเขียน Log แบบง่ายๆ ที่จะบอกว่าเรียก API ตอนไหน ส่งอะไรไป ได้รับอะไรกลับมา

การติดตั้งและเขียน Log เบื้องต้น

import logging
import requests
import json
from datetime import datetime


ตั้งค่า logging ให้เห็นรายละเอียดทุกขั้นตอน

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(message)s',
    datefmt='%H:%M:%S'
)
logger = logging.getLogger(__name__)


ตั้งค่า API สำหรับเรียก HolySheep AI

BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"

def debug_api_call(endpoint, payload):
    """ฟังก์ชันเรียก API พร้อมแสดง log ทุกขั้นตอน"""

    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    url = f"{BASE_URL}/{endpoint}"

    # บันทึกว่าจะส่งอะไรไป
    logger.info(f"เรียก API: {url}")
    logger.debug(f"Payload ที่ส่ง: {json.dumps(payload, ensure_ascii=False, indent=2)}")

    try:
        response = requests.post(url, json=payload, headers=headers, timeout=30)

        # บันทึกสถานะการตอบกลับ
        logger.info(f"สถานะ: {response.status_code}")
        logger.debug(f"Response headers: {dict(response.headers)}")

        result = response.json()
        logger.info(f"Response ที่ได้รับ: {json.dumps(result, ensure_ascii=False, indent=2)[:500]}")
        return result

    except requests.exceptions.Timeout:
        logger.error("เกิดข้อผิดพลาด: รอนานเกินไป (Timeout)")
        return None

    except requests.exceptions.ConnectionError as e:
        logger.error(f"เกิดข้อผิดพลาด: เชื่อมต่อไม่ได้ - {e}")
        return None

    except Exception as e:
        logger.error(f"เกิดข้อผิดพลาดที่ไม่คาดคิด: {type(e).__name__} - {e}")
        return None


ทดสอบการเรียกใช้

if __name__ == "__main__":
    logger.info("=== เริ่มทดสอบ MCP Tool ===")

    test_payload = {
        "model": "gpt-4.1",
        "messages": [{"role": "user", "content": "ทดสอบการเชื่อมต่อ"}],
        "temperature": 0.7
    }

    result = debug_api_call("chat/completions", test_payload)

    if result:
        logger.info("เรียก API สำเร็จ!")
    else:
        logger.warning("เรียก API ไม่สำเร็จ ตรวจสอบ log ข้างบน")

เมื่อรันโค้ดนี้ หน้าจอจะแสดงลำดับการทำงานทั้งหมด ตั้งแต่ส่งคำขอไปจนได้รับคำตอบ ผมใช้วิธีนี้ตอนพัฒนาโปรเจกต์แรกและเชื่อผมเถอะว่ามันช่วยได้มากจริงๆ

ขั้นตอนที่ 2: อ่าน Error Response ให้ออก

เมื่อ API ตอบกลับมาว่ามีปัญหา มันจะส่งข้อความที่บอกสาเหตุมาด้วยเสมอ ตรงนี้คือจุดสำคัญที่หลายคนมองข้าม ผมจะสอนวิธีแยกแยะประเภท Error

import requests
import json

BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"

def analyze_error_response(response):
    """วิเคราะห์ Error จาก API response และแนะนำวิธีแก้"""

    error_analysis = []

    try:
        data = response.json()
    except:
        error_analysis.append("ไม่สามารถอ่าน Response ได้ (อาจเป็นปัญหาเครือข่าย)")
        return error_analysis

    # กรณีมี field error โดยตรง
    if "error" in data:
        error = data["error"]
        code = error.get("code", "ไม่ระบุ")
        message = error.get("message", "ไม่มีข้อความ")

        if code == "invalid_api_key":
            error_analysis.append(f"รหัส API Key ไม่ถูกต้อง: {message}")
            error_analysis.append("วิธีแก้: ไปที่ https://www.holysheep.ai/register เพื่อรับ API Key ใหม่")

        elif code == "rate_limit_exceeded":
            error_analysis.append(f"เกินขีดจำกัดการใช้งาน: {message}")
            error_analysis.append("วิธีแก้: รอสักครู่แล้วลองใหม่ หรืออัปเกรดแพลน")

        elif code == "model_not_found":
            error_analysis.append(f"ไม่พบโมเดลที่ระบุ: {message}")
            error_analysis.append("วิธีแก้: ตรวจสอบชื่อโมเดล — เช่น gpt-4.1, claude-sonnet-4.5, gemini-2.5-flash, deepseek-v3.2")

        elif code == "context_length_exceeded":
            error_analysis.append(f"ข้อความยาวเกินขีดจำกัด: {message}")
            error_analysis.append("วิธีแก้: ตัดข้อความให้สั้นลง หรือใช้โมเดลที่รองรับ Context ยาวกว่า")

        elif code == "invalid_request_error":
            error_analysis.append(f"รูปแบบคำขอผิดพลาด: {message}")
            error_analysis.append("วิธีแก้: ตรวจสอบโครงสร้าง JSON ว่าครบถ้วนและถูกต้อง")

        else:
            error_analysis.append(f"Error code: {code}")
            error_analysis.append(f"ข้อความ: {message}")
            error_analysis.append("วิธีแก้: ติดต่อฝ่ายสนับสนุนของ HolySheep AI")

    # กรณีเป็น HTTP status error
    if response.status_code == 401:
        error_analysis.append("HTTP 401: ไม่ได้รับอนุญาต — ตรวจสอบ API Key")
    elif response.status_code == 403:
        error_analysis.append("HTTP 403: ถูกปฏิเสธ — อาจไม่มีสิทธิ์เข้าถึง")
    elif response.status_code == 429:
        error_analysis.append("HTTP 429: เรียกบ่อยเกินไป — รอแล้วลองใหม่")
    elif response.status_code >= 500:
        error_analysis.append(f"HTTP {response.status_code}: เซิร์ฟเวอร์มีปัญหา — รอสักครู่")

    return error_analysis


def test_with_error_handling():
    """ทดสอบการเรียก API พร้อมแสดงวิธีแก้ปัญหา"""

    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }

    payload = {
        "model": "gpt-4.1",
        "messages": [{"role": "user", "content": "ทดสอบ"}]
    }

    response = requests.post(
        f"{BASE_URL}/chat/completions",
        json=payload,
        headers=headers
    )

    print("=== ผลการวิเคราะห์ Error ===")
    if response.status_code == 200:
        print("สำเร็จ: API ทำงานได้ปกติ")
        print(f"คำตอบ: {response.json().get('choices', [{}])[0].get('message', {}).get('content', '')}")
    else:
        errors = analyze_error_response(response)
        for i, err in enumerate(errors, 1):
            print(f"{i}. {err}")

test_with_error_handling()

โค้ดนี้จะช่วยให้เราเข้าใจ Error ที่เกิดขึ้น และรู้ว่าต้องแก้อย่างไร แทนที่จะนั่งเดาสุ่ม

ขั้นตอนที่ 3: สร้าง MCP Debugger Tool สำหรับติดตาม Request-Response

ถ้าคุณใช้ MCP Tool หลายตัวพร้อมกัน การติดตามทีละอันจะยุ่งยากมาก ผมเลยเขียน Debugger Tool ที่รวมทุกอย่างเข้าด้วยกัน

import time
import logging
from datetime import datetime
from collections import defaultdict
import threading

logger = logging.getLogger("MCP_Debugger")

class MCPDebugger:
    """
    เครื่องมือ Debugger สำหรับ MCP Tool
    บันทึกทุก request, response, error และวิเคราะห์ปัญหา
    """

    def __init__(self, name="MCP_Debugger"):
        self.name = name
        self.request_log = []
        self.error_log = []
        self.performance_log = []
        self.lock = threading.Lock()
        logger.info(f"MCPDebugger เริ่มทำงาน: {name}")

    def log_request(self, tool_name, endpoint, payload, request_id):
        """บันทึกการเรียกใช้งาน"""
        entry = {
            "timestamp": datetime.now().isoformat(),
            "request_id": request_id,
            "tool": tool_name,
            "endpoint": endpoint,
            "payload_size": len(str(payload)),
            "status": "pending"
        }
        with self.lock:
            self.request_log.append(entry)
        logger.debug(f"[{request_id}] {tool_name} เรียก {endpoint}")
        return entry

    def log_response(self, request_id, response_data, duration_ms, status_code):
        """บันทึกการตอบกลับ"""
        entry = {
            "request_id": request_id,
            "timestamp": datetime.now().isoformat(),
            "duration_ms": round(duration_ms, 2),
            "status_code": status_code,
            "response_size": len(str(response_data))
        }

        with self.lock:
            # อัปเดต status ใน request_log
            for req in reversed(self.request_log):
                if req["request_id"] == request_id:
                    req["status"] = "success" if status_code == 200 else "error"
                    break

            self.performance_log.append(entry)

        logger.info(f"[{request_id}] เสร็จสิ้น ({duration_ms:.1f}ms) สถานะ: {status_code}")

    def log_error(self, request_id, error_message, error_type):
        """บันทึกข้อผิดพลาดพร้อมวิเคราะห์"""
        entry = {
            "request_id": request_id,
            "timestamp": datetime.now().isoformat(),
            "error_type": error_type,
            "message": error_message
        }

        with self.lock:
            self.error_log.append(entry)

        logger.error(f"[{request_id}] Error {error_type}: {error_message}")

        # แนะนำวิธีแก้ไขอัตโนมัติ
        suggestion = self._suggest_fix(error_type, error_message)
        if suggestion:
            logger.info(f"[{request_id}] วิธีแก้ไข: {suggestion}")

    def _suggest_fix(self, error_type, message):
        """แนะนำวิธีแก้ไขอัตโนมัติตามประเภทข้อผิดพลาด"""
        suggestions = {
            "TimeoutError": "เพิ่มค่า timeout หรือตรวจสอบการเชื่อมต่ออินเทอร์เน็ต",
            "ConnectionError": "ตรวจสอบ URL และสถานะเซิร์ฟเวอร์ ลองใช้คำสั่ง: curl https://api.holysheep.ai/v1/models",
            "AuthenticationError": "ตรวจสอบ API Key ที่ https://www.holysheep.ai/register ว่าถูกต้อง",
            "JSONDecodeError": "ตรวจสอบว่า Response เป็น JSON ที่ถูกต้อง ลองเพิ่ม try-except",
            "RateLimitError": "รอ 60 วินาทีแล้วลองใหม่ พิจารณาอัปเกรดแพลน"
        }
        return suggestions.get(error_type, "ตรวจสอบ log ข้างบนสำหรับรายละเอียดเพิ่มเติม")

    def get_statistics(self):
        """สรุปสถิติการทำงานทั้งหมด"""
        total = len(self

แหล่งข้อมูลที่เกี่ยวข้อง
บทความที่เกี่ยวข้อง