บทนำ: ทำไมต้องมีระบบเลือกโมเดลอัตโนมัติ

สวัสดีครับ ผมเป็นนักพัฒนาที่ใช้ AI API มาหลายปี วันนี้จะมาสอนเพื่อนๆ ที่ยังไม่เคยใช้ API เลย สร้างระบบอัจฉริยะที่จะเลือกโมเดล AI ให้เอง โดยคำนึงถึงความเร็วในการตอบสนองและค่าใช้จ่าย ช่วยประหยัดเงินได้มากกว่า 85% เลยทีเดียว

ปัญหาที่หลายคนเจอคือ ใช้ GPT-4.1 ทำงานทุกอย่าง ทั้งที่บางงานแค่ถามคำถามง่ายๆ ใช้โมเดลราคาถูกกว่า 20 เท่าก็เพียงพอแล้ว ระบบ HolySheep AI ช่วยให้เราควบคุมต้นทุนได้อย่างชาญฉลาด โดยมีราคาเริ่มต้นที่เพียง DeepSeek V3.2 ราคา $0.42 ต่อล้านตัวอักษร เทียบกับ GPT-4.1 ที่ $8 ต่อล้านตัวอักษร

หลักการทำงานของระบบ Router

ระบบที่เราจะสร้างจะทำงาน 3 ขั้นตอนหลัก ดังนี้:

เริ่มต้นสร้างโปรเจกต์ Step by Step

ขั้นตอนที่ 1: ติดตั้ง Python และ Library ที่ต้องใช้

สำหรับผู้เริ่มต้น ให้ดาวน์โหลด Python จาก python.org ก่อนนะครับ จากนั้นเปิด Command Prompt (พิมพ์ cmd ในช่องค้นหา Windows) แล้วพิมพ์คำสั่งติดตั้งดังนี้:

pip install requests python-dotenv httpx aiohttp

หลังติดตั้งเสร็จ ทดลองพิมพ์ python --version เพื่อตรวจสอบว่าติดตั้งสำเร็จหรือไม่ ถ้าขึ้นเวอร์ชัน 3.8 ขึ้นไปถือว่าโอเคครับ

ขั้นตอนที่ 2: สร้างไฟล์ config สำหรับเก็บราคาโมเดล

สร้างโฟลเดอร์ชื่อ ai-router แล้วสร้างไฟล์ชื่อ models.py ภายในโฟลเดอร์นั้น ไฟล์นี้จะเก็บข้อมูลราคาและความสามารถของแต่ละโมเดล:

# models.py

ข้อมูลราคาโมเดลต่อ 1 ล้านตัวอักษร (อัปเดต มกราคม 2026)


MODEL_CONFIG = {
    "gpt-4.1": {
        "name": "GPT-4.1",
        "price_per_mtok": 8.00,  # $8 ต่อล้านตัวอักษร
        "max_tokens": 128000,
        "strengths": ["เหมาะกับงานซับซ้อน", "เขียนโค้ดเก่งมาก", "เข้าใจบริบทยาว"],
        "best_for": ["เขียนโปรแกรม", "วิเคราะห์ข้อมูล", "งานวิจัย"]
    },
    "claude-sonnet-4.5": {
        "name": "Claude Sonnet 4.5",
        "price_per_mtok": 15.00,  # $15 ต่อล้านตัวอักษร
        "max_tokens": 200000,
        "strengths": ["เขียนเรียงความสวย", "ตอบคำถามลึก", "มีจริยธรรมดี"],
        "best_for": ["เขียนบทความ", "สรุปหนังสือ", "งานสร้างสรรค์"]
    },
    "gemini-2.5-flash": {
        "name": "Gemini 2.5 Flash",
        "price_per_mtok": 2.50,  # $2.50 ต่อล้านตัวอักษร
        "max_tokens": 1000000,
        "strengths": ["เร็วมาก", "ราคาถูก", "รองรับมัลติโมดัล"],
        "best_for": ["ถามตอบเร็ว", "งานทั่วไป", "แชทบอท"]
    },
    "deepseek-v3.2": {
        "name": "DeepSeek V3.2",
        "price_per_mtok": 0.42,  # $0.42 ต่อล้านตัวอักษร
        "max_tokens": 64000,
        "strengths": ["ราคาถูกที่สุด", "เข้าใจภาษาไทยดี", "โอเพนซอร์ส"],
        "best_for": ["งานง่ายๆ", "ถามตอบทั่วไป", "บอทตอบลูกค้า"]
    }
}


น้ำหนักความสำคัญ (ปรับได้ตามต้องการ)

WEIGHTS = {
    "latency_weight": 0.4,   # น้ำหนักความเร็ว 40%
    "cost_weight": 0.6      # น้ำหนักราคา 60%
}

ขั้นตอนที่ 3: สร้างระบบวัดความเร็ว (Ping Test)

ไฟล์ latency.py จะทำหน้าที่วัดความเร็วในการตอบสนองของแต่ละโมเดล โดยส่งคำถามทดสอบเล็กๆ ไปแล้วจับเวลา:

# latency.py
import time
import requests
from typing import Dict


ตั้งค่า API ของ HolySheep

BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # แทนที่ด้วย API Key ของคุณ

def test_latency(model_id: str, test_prompt: str = "สวัสดีครับ") -> float:
    """
    ทดสอบความเร็วของโมเดล
    ส่งคืนค่า latency เป็นมิลลิวินาที
    """
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    data = {
        "model": model_id,
        "messages": [
            {"role": "user", "content": test_prompt}
        ],
        "max_tokens": 10  # จำกัด max_tokens ให้น้อย เพื่อวัดความเร็วที่แท้จริง
    }
    
    start_time = time.time()
    
    try:
        response = requests.post(
            f"{BASE_URL}/chat/completions",
            headers=headers,
            json=data,
            timeout=30
        )
        end_time = time.time()
        
        if response.status_code == 200:
            # คำนวณเวลาเป็นมิลลิวินาที
            latency_ms = (end_time - start_time) * 1000
            return round(latency_ms, 2)
        else:
            print(f"❌ เกิดข้อผิดพลาด: {response.status_code} - {response.text}")
            return 99999  # ค่าเริ่มต้นถ้าล้มเหลว
            
    except requests.exceptions.Timeout:
        print(f"⏰ Timeout สำหรับ {model_id}")
        return 99999
    except Exception as e:
        print(f"⚠️ ข้อผิดพลาด: {str(e)}")
        return 99999

def benchmark_all_models() -> Dict[str, float]:
    """
    วัดความเร็วของทุกโมเดล
    ส่งคืน dictionary {model_id: latency_ms}
    """
    models = ["gpt-4.1", "claude-sonnet-4.5", "gemini-2.5-flash", "deepseek-v3.2"]
    results = {}
    
    print("🔄 กำลังวัดความเร็วของแต่ละโมเดล...\n")
    
    for model in models:
        print(f"📡 ทดสอบ {model}...", end=" ")
        latency = test_latency(model)
        results[model] = latency
        print(f"{latency} ms")
    
    return results

if __name__ == "__main__":
    results = benchmark_all_models()
    print("\n📊 ผลการวัดความเร็ว:")
    for model, latency in sorted(results.items(), key=lambda x: x[1]):
        print(f"   {model}: {latency} มิลลิวินาที")

ขั้นตอนที่ 4: สร้างระบบ Router หลัก

ไฟล์ router.py เป็นหัวใจหลักของระบบ จะทำการคำนวณคะแนนรวมของแต่ละโมเดลแล้วเลือกตัวที่ดีที่สุด:

# router.py
from typing import Dict, List, Optional
from models import MODEL_CONFIG, WEIGHTS
from latency import test_latency

class SmartRouter:
    """
    ระบบเลือกโมเดลอัจฉริยะ
    พิจารณาจากความเร็วและราคา
    """
    
    def __init__(self):
        self.latency_cache: Dict[str, float] = {}
        self.cache_valid_duration = 300  # แคช 5 นาที
        self.last_benchmark_time = 0
    
    def calculate_latency_score(self, latency_ms: float, max_latency: float) -> float:
        """
        คำนวณคะแนนความเร็ว
        ยิ่งเร็ว = คะแนนสูง (1-100)
        """
        if max_latency == 0:
            return 100
        # ความเร็วสูงสุดที่เป็นไปได้ 50ms เมื่อใช้ HolySheep
        normalized = max(0, (100 - (latency_ms / 50)))
        return min(100, normalized)
    
    def calculate_cost_score(self, price_per_mtok: float, min_price: float) -> float:
        """
        คำนวณคะแนนราคา
        ยิ่งถูก = คะแนนสูง (1-100)
        """
        if price_per_mtok == 0:
            return 100
        # DeepSeek V3.2 ราคา $0.42 เป็นราคาต่ำสุด
        ratio = min_price / price_per_mtok
        return min(100, ratio * 20)
    
    def get_cached_latency(self, model_id: str) -> float:
        """
        ดึงค่า latency

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