บทนำ: ทำไมโรงอาหารมหาวิทยาลัยต้องการ Smart Recipe API

ในยุคที่นักศึกษาทั่วโลกให้ความสำคัญกับสุขภาพและโภชนาการมากขึ้น โรงอาหารมหาวิทยาลัยจำเป็นต้องปรับตัว ระบบ Smart Recipe API ที่พัฒนาด้วย HolySheep AI ช่วยให้สามารถวิเคราะห์คุณค่าทางโภชนาการของเมนูอาหารแต่ละจาน ระบุวัตถุดิบจากภาพถ่าย และสร้างเมนูที่สมดุลทางโภชนาการโดยอัตโนมัติ บทความนี้จะอธิบายวิธีการสร้างระบบ API สำหรับโรงอาหารมหาวิทยาลัยที่ใช้ GPT-4o วิเคราะห์คุณค่าทางโภชนาการ ผสมผสานการรู้จำวัตถุดิบด้วย Gemini และตั้งค่า Fallback หลายระดับเพื่อให้มั่นใจว่าระบบจะทำงานได้ตลอดเวลา

ตารางเปรียบเทียบ: HolySheep AI vs OpenAI Official vs บริการรีเลย์อื่นๆ

เกณฑ์เปรียบเทียบ HolySheep AI OpenAI Official API รีเลย์ทั่วไป
ราคา GPT-4o (per 1M tokens) $8.00 (ประหยัด 85%+) $15.00 $10-$14
ราคา Claude Sonnet 4.5 $15.00 $18.00 $16-$20
ราคา Gemini 2.5 Flash $2.50 $3.50 $3.00-$5.00
ราคา DeepSeek V3.2 $0.42 ไม่มีบริการ $0.50-$1.00
ความเร็ว (Latency) <50ms 100-300ms 80-200ms
วิธีการชำระเงิน WeChat Pay, Alipay, USD บัตรเครดิตสากล หลากหลาย
เครดิตฟรีเมื่อลงทะเบียน ✅ มี ❌ ไม่มี ขึ้นอยู่กับผู้ให้บริการ
Multi-Model Fallback ✅ รองรับทุกโมเดล ❌ เฉพาะ OpenAI จำกัด
การรองรับ WeChat/Alipay ✅ รองรับเต็มรูปแบบ ❌ ไม่รองรับ บางส่วน

เหมาะกับใคร / ไม่เหมาะกับใคร

✅ เหมาะกับใคร

❌ ไม่เหมาะกับใคร

สถาปัตยกรรมระบบ Smart Recipe API

ระบบ Smart Recipe API สำหรับโรงอาหารมหาวิทยาลัยประกอบด้วย 4 ส่วนหลัก:
  1. Recipe Generation Layer — ใช้ GPT-4o สร้างเมนูที่สมดุลทางโภชนาการ
  2. Ingredient Recognition Layer — ใช้ Gemini รู้จำวัตถุดิบจากภาพ
  3. Nutrition Analysis Layer — วิเคราะห์คุณค่าทางโภชนาการด้วย DeepSeek V3.2
  4. Fallback & Monitoring Layer — ระบบสำรองและการแจ้งเตือน

การติดตั้งและโค้ดตัวอย่าง

1. การตั้งค่า Base Configuration

import requests
import json
import time
from typing import Optional, Dict, Any, List
from datetime import datetime
import logging


ตั้งค่า Logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


============================================


การตั้งค่า HolySheep AI API


============================================

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

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

class HolySheepClient:
    """
    Client สำหรับเชื่อมต่อกับ HolySheep AI API
    รองรับ Multi-Model Fallback อัตโนมัติ
    """
    
    MODELS = {
        "gpt4o": {
            "name": "gpt-4o",
            "price_per_mtok": 8.00,
            "use_case": "nutrition_analysis"
        },
        "gemini": {
            "name": "gemini-2.5-flash",
            "price_per_mtok": 2.50,
            "use_case": "ingredient_recognition"
        },
        "deepseek": {
            "name": "deepseek-v3.2",
            "price_per_mtok": 0.42,
            "use_case": "fallback_cheap"
        },
        "claude": {
            "name": "claude-sonnet-4.5",
            "price_per_mtok": 15.00,
            "use_case": "premium_analysis"
        }
    }
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.HEADERS["Authorization"] = f"Bearer {api_key}"
        self.request_count = 0
        self.total_cost = 0.0
        self.latencies = []
    
    def chat_completion(
        self,
        model: str,
        messages: List[Dict],
        temperature: float = 0.7,
        max_tokens: int = 2000
    ) -> Optional[Dict[str, Any]]:
        """
        ส่งคำขอไปยัง HolySheep AI Chat Completion API
        """
        endpoint = f"{BASE_URL}/chat/completions"
        payload = {
            "model": self.MODELS[model]["name"],
            "messages": messages,
            "temperature": temperature,
            "max_tokens": max_tokens
        }
        
        start_time = time.time()
        
        try:
            response = requests.post(
                endpoint,
                headers=self.HEADERS,
                json=payload,
                timeout=30
            )
            
            latency = (time.time() - start_time) * 1000  # แปลงเป็น milliseconds
            
            # บันทึก metrics
            self.latencies.append(latency)
            self.request_count += 1
            
            if response.status_code == 200:
                result = response.json()
                usage = result.get("usage", {})
                
                # คำนวณค่าใช้จ่าย
                prompt_tokens = usage.get("prompt_tokens", 0)
                completion_tokens = usage.get("completion_tokens", 0)
                total_tokens = prompt_tokens + completion_tokens
                
                cost = (total_tokens / 1_000_000) * self.MODELS[model]["price_per_mtok"]
                self.total_cost += cost
                
                logger.info(f"✅ {model} | Latency: {latency:.2f}ms | Cost: ${cost:.6f}")
                
                return {
                    "success": True,
                    "data": result,
                    "latency_ms": latency,
                    "cost": cost
                }
            else:
                logger.error(f"❌ Error {response.status_code}: {response.text}")
                return None
                
        except requests.exceptions.Timeout:
            logger.error(f"⏰ Timeout กับ model: {model}")
            return None
        except Exception as e:
            logger.error(f"💥 Exception: {str(e)}")
            return None

print("✅ HolySheep Client พร้อมใช้งานแล้ว!")

2. ระบบ Fallback แบบ Multi-Model

class SmartRecipeAPIService:
    """
    ระบบ Smart Recipe API สำหรับโรงอาหารมหาวิทยาลัย
    รองรับ Multi-Model Fallback อัตโนมัติ
    """
    
    def __init__(self, api_key: str):
        self.client = HolySheepClient(api_key)
        self.alert_threshold_ms = 500  # ms
        self.alert_threshold_cost = 0.10  # $ ต่อ request
        self.alerts = []
    
    def analyze_recipe_nutrition(self, recipe: Dict) -> Optional[Dict]:
        """
        วิเคราะห์คุณค่าทางโภชนาการของสูตรอาหาร
        ลำดับการ fallback: gpt4o -> deepseek -> claude
        """
        prompt = f"""
        วิเคราะห์คุณค่าทางโภชนาการของสูตรอาหารต่อไปนี้:
        
        ชื่อเมนู: {recipe.get('name', 'ไม่ระบุ')}
        ส่วนผสม:
        {json.dumps(recipe.get('ingredients', []), ensure_ascii=False, indent=2)}
        
        กรุณาวิเคราะห์และส่งข้อมูลในรูปแบบ JSON:
        {{
            "calories": จำนวนแคลอรี่ (kcal),
            "protein": ปริมาณโปรตีน (g),
            "carbs": ปริมาณคาร์โบไฮเดรต (g),
            "fat": ปริมาณไขมัน (g),
            "fiber": ปริมาณใยอาหาร (g),
            "vitamins": ["วิตามินที่พบ"],
            "minerals": ["แร่ธาตุที่พบ"],
            "score": คะแนนโภชนาการ (1-100)
        }}
        """
        
        messages = [{"role": "user", "content": prompt}]
        
        # ลำดับการ Fallback
        models_to_try = ["gpt4o", "deepseek", "claude"]
        
        for model in models_to_try:
            logger.info(f"🔄 ลองใช้ model: {model}")
            
            result = self.client.chat_completion(
                model=model,
                messages=messages,
                temperature=0.3,
                max_tokens=1500
            )
            
            if result and result["success"]:
                # ตรวจสอบ latency threshold
                if result["latency_ms"] > self.alert_threshold_ms:
                    self._send_alert(
                        "HIGH_LATENCY",
                        f"Model {model} latency: {result['latency_ms']:.2f}ms"
                    )
                
                return {
                    "model_used": model,
                    "nutrition": json.loads(result["data"]["choices"][0]["message"]["content"]),
                    "latency_ms": result["latency_ms"],
                    "cost": result["cost"]
                }
            else:
                logger.warning(f"⚠️ Model {model} ล้มเหลว ลองตัวถัดไป")
                continue
        
        # ถ้าทุก model ล้มเหลว
        self._send_alert("ALL_MODELS_FAILED", "ไม่สามารถเชื่อมต่อได้ทั้งหมด")
        return None
    
    def recognize_ingredients(self, image_base64: str) -> Optional[Dict]:
        """
        รู้จำวัตถุดิบจากภาพ
        ลำดับการ fallback: gemini -> gpt4o
        """
        prompt = """
        จากภาพอาหารที่ส่งมา กรุณาระบุวัตถุดิบทั้งหมดที่พบ
        และประมาณการปริมาณของแต่ละวัตถุดิบ
        
        ตอบกลับในรูปแบบ JSON:
        {
            "ingredients": [
                {"name": "ชื่อวัตถุดิบ", "amount": "ปริมาณโดยประมาณ", "confidence": 0.0-1.0}
            ],
            "dish_name": "ชื่อเมนูที่ระบุได้"
        }
        """
        
        messages = [
            {"role": "user", "content": [
                {"type": "text", "text": prompt},
                {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_base64}"}}
            ]}
        ]
        
        # ลำดับการ Fallback
        models_to_try = ["gemini", "gpt4o"]
        
        for model in models_to_try:
            logger.info(f"🔄 ลองใช้ model รู้จำวัตถุดิบ: {model}")
            
            result = self.client.chat_completion(
                model=model,
                messages=messages,
                temperature=0.2,
                max_tokens=1000
            )
            
            if result and result["success"]:
                return {
                    "model_used": model,
                    "ingredients": json.loads(result["data"]["choices"][0]["message"]["content"]),
                    "latency_ms": result["latency_ms"],
                    "cost": result["cost"]
                }
            continue
        
        self._send_alert("IMAGE_RECOGNITION_FAILED", "ไม่สามารถรู้จำภาพได้")
        return None
    
    def generate_balanced_menu(self, constraints: Dict) -> Optional[Dict]:
        """
        สร้างเมนูที่สมดุลทางโภชนาการตามข้อจำกัดที่กำหนด
        """
        prompt = f"""
        ออกแบบเมนูอาหารมังสวิรัติ/กึ่งมังสวิรัติสำหรับโรงอาหารมหาวิทยาลัย
        ที่มีความสมดุลทางโภชนาการตามเงื่อนไขต่อไปนี้:
        
        - งบประมาณต่อมื้อ: {constraints.get('budget', 50)} หยวน
        - จำนวนนักศึกษา: {constraints.get('servings', 100)} คน
        - ข้อจำกัดด้านอาหาร: {constraints.get('restrictions', 'ไม่มี')}
        - ความต้องการแคลอรี่: {constraints.get('calorie_target', '2000')} kcal/วัน
        
        ออกแบบเมนู 3 มื้อ (เช้า กลางวัน เย็น) พร้อมคุณค่าทางโภชนาการโดยประมาณ
        """
        
        messages = [{"role": "user", "content": prompt}]
        
        result = self.client.chat_completion(
            model="gpt4o",
            messages=messages,
            temperature=0.7,
            max_tokens=3000
        )
        
        if result and result["success"]:
            return {
                "model_used": "gpt4o",
                "menu": result["data"]["choices"][0]["message"]["content"],
                "latency_ms": result["latency_ms"],
                "cost": result["cost"]
            }
        
        return None
    
    def _send_alert(self, alert_type: str, message: str):
        """
        ส่งการแจ้งเตือนเมื่อเกิดปัญหา
        """
        alert = {
            "type": alert_type,
            "message": message,
            "timestamp": datetime.now().isoformat(),
            "client_state": {
                "total_requests": self.client.request_count,
                "total_cost": self.client.total_cost,
                "avg_latency_ms": sum(self.client.latencies) / len(self.client.latencies) if self.client.latencies else 0
            }
        }
        
        self.alerts.append(alert)
        logger.critical(f"🚨 ALERT: {alert_type} - {message}")
        
        # TODO: ส่ง notification ไปยัง Slack/Discord/Email
    
    def get_system_metrics(self) -> Dict:
        """
        ดึงข้อมูล metrics ของระบบ
        """
        avg_latency = sum(self.client.latencies) / len(self.client.latencies) if self.client.latencies else 0
        
        return {
            "total_requests": self.client.request_count,
            "total_cost_usd": round(self.client.total_cost, 6),
            "total_cost_cny": round(self.client.total_cost, 2),  # ¥1=$1
            "avg_latency_ms": round(avg_latency, 2),
            "min_latency_ms": round(min(self.client.latencies), 2) if self.client.latencies else 0,
            "max_latency_ms": round(max(self.client.latencies), 2) if self.client.latencies else 0,
            "alert_count": len(self.alerts),
            "recent_alerts": self.alerts[-5:] if len(self.alerts) > 5 else self.alerts
        }


ทดสอบการใช้งาน

service = SmartRecipeAPIService("YOUR_HOLYSHEEP_API_KEY")


ทดสอบวิเคราะห์โภชนาการ

test_recipe = {
    "name": "ผัดกะเพราไก่",
    "ingredients": [
        {"name": "เนื้อไก่", "amount": "200g"},
        {"name": "ใบกะเพรา", "amount": "50g"},
        {"name": "พริก", "amount": "10g"},
        {"name": "กระเทียม", "amount": "15g"},
        {"name": "น้ำมัน", "amount": "20ml"}
    ]
}

result = service.analyze_recipe_nutrition(test_recipe)
if result:
    print(f"✅ วิเคราะห์สำเร็จด้วย {result['model_used']}")
    print(f"📊 Latency: {result['latency_ms']:.2f}ms")
    print(f"💰 Cost: ${result['cost']:.6f}")
    print(json.dumps(result["nutrition"], ensure_ascii=False, indent=2))

print("\n📈 System Metrics:", json.dumps(service.get_system_metrics(), indent=2))

3. ระบบ Monitoring Dashboard API

from flask import Flask, jsonify, request
import threading
import time

app = Flask(__name__)


ตัวแปร Global

service = None
monitoring_data = {
    "requests_per_minute": [],
    "error_rate": [],
    "avg_latency": [],
    "cost_per_hour": []
}

def background_monitor():
    """
    ทำงานเบื้องหลัง ตรวจสอบสถานะระบบทุก 60 วินาที
    """
    while True:
        if service:
            metrics = service.get_system_metrics()
            
            monitoring_data["requests_per_minute"].append({
                "timestamp": time.time(),
                "count": metrics["total_requests"]
            })
            
            monitoring_data["avg_latency"].append({
                "timestamp": time.time(),
                "latency_ms": metrics["avg_latency_ms"]
            })
            
            # ตรวจสอบ error rate
            if metrics["alert_count"] > 0:
                error_rate = metrics["alert_count"] / metrics["total_requests"] * 100
                monitoring_data["error_rate"].append({
                    "timestamp": time.time(),
                    "error_rate": round(error_rate, 2)
                })
            
            # Alert หาก latency สูงผิดปกติ
            if metrics["avg_latency_ms"] > 200:
                service._send_alert(
                    "SLOW_RESPONSE",
                    f"ค่าเฉลี่ย latency: {metrics['avg_latency_ms']:.2f}ms"
                )
            
            # Alert หากค่าใช้จ่ายสูงเกิน
            if metrics["total_cost_usd"] > 100:
                service._send_alert(
                    "HIGH_COST",
                    f"ค่าใช้จ่ายสะสม: ${metrics['total_cost_usd']:.2f}"
                )
        
        time.sleep(60)

@app.route("/api/v1/canteen/recipe/analyze", methods=["POST"])
def analyze_recipe():
    """
    API Endpoint สำหรับวิเคราะห์สูตรอาหาร
    """
    data = request.get_json()
    
    if not data or "recipe" not in data:
        return jsonify({"error": "กรุณาส่งข้อมูลสูตรอาหาร"}), 400
    
    result = service.analyze_recipe_nutrition(data["recipe"])
    
    if result:
        return jsonify({
            "success": True,
            "data": result
        })
    else:
        return jsonify({
            "success": False,
            "error": "ไม่สามารถวิเคราะห์ได้ กรุณาลองใหม่ภายหลัง"
        }), 503

@app.route("/api/v1/canteen/ingredients/recognize", methods=["POST"])
def recognize_ingredients():
    """
    API Endpoint สำหรับรู้จำวัตถุดิบจากภาพ
    """
    data = request.get_json()
    
    if not data or "image" not in data:
        return jsonify({"error": "กรุณาส่งภาพ base64"}), 400
    
    result = service.recognize_ingredients(data["image"])
    
    if result:
        return jsonify({
            "success": True,
            "data": result
        })
    else:
        return jsonify({
            "success": False,
            "error": "ไม่สามารถรู้จำภาพได้"
        }), 503

@app.route("/api/v1/canteen/menu/generate", methods=["POST"])
def generate_menu():
    """
    API Endpoint สำหรับสร้างเมนู
    """
    data = request.get_json() or {}
    
    constraints = {
        "budget": data.get("budget", 50),
        "servings": data.get("servings", 100),
        "restrictions": data.get("restrictions", "ไม่มี"),
        "calorie_target": data.get("calorie_target", "2000")
    }
    
    result = service.generate_balanced_menu(constraints)
    
    if result:
        return jsonify({
            "success": True,
            "data": result
        })
    else:
        return jsonify({
            "success": False,
            "error": "ไม่สามารถสร้างเมนูได้"
        }), 503

@app.route("/api/v1/metrics", methods=["GET"])
def get_metrics():
    """
    API Endpoint สำหรับดู Metrics
    """
    return jsonify(service.get_system_metrics())

@app.route("/api/v1/alerts", methods=["GET"])
def get_alerts():
    """
    API Endpoint สำหรับดู Alert ล่าสุด
    """
    limit = request.args.get("limit", 10, type=int)
    return jsonify({
        "total_alerts": len(service.alerts),
        "alerts": service.alerts[-limit:]
    })

@app.route("/api/v1/health", methods=["GET"])
def health_check():
    """
    Health Check Endpoint
    """
    return jsonify({
        "status": "healthy",
        "timestamp": datetime.now().isoformat()
    })

if __name__ == "__main__":
    # เริ่มต้น service
    service = SmartRecipeAPIService("YOUR_HOLYSHEEP_API_KEY")
    
    # เริ่ม background monitor
    monitor_thread = threading.Thread(target=background_monitor, daemon=True)
    monitor_thread

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