ผมเคยเจอปัญหา ConnectionError: timeout ทุกครั้งที่พยายามสร้างระบบติวเตอร์ AI แบบง่ายๆ เพื่อช่วยนักเรียนทำการบ้าน โค้ดดูสมบูรณ์ ทำไมมันถึง timeout ทุกที ปัญหาคือผมลืมส่ง conversation history ไปด้วย ทำให้ AI ตอบซ้ำๆ และสุดท้ายก็ timeout ไปซะงั้น วันนี้ผมจะมาแชร์วิธีแก้ปัญหานี้และสอนสร้างระบบติวเตอร์ AI ที่ทำงานได้จริง

ทำไมต้องมี Conversation History?

ระบบติวเตอร์ AI ที่ดีต้อง "จำ" สิ่งที่สนทนามาก่อนได้ เช่น นักเรียนถามเรื่องสมการ ครูตอบไปแล้ว แล้วนักเรียนถามต่อ ครูก็ต้องรู้ว่ากำลังพูดถึงสมการอะไรอยู่ ถ้าไม่ส่ง history ทุกครั้ง AI ก็จะตอบแบบ "เริ่มใหม่ทุกข้อ" ซึ่งทำให้ประสบการณ์การเรียนแย่มาก

สำหรับโปรเจกต์นี้ ผมใช้ HolySheep AI เพราะมี latency ต่ำกว่า 50ms ทำให้การสนทนาเป็นธรรมชาติ และราคาถูกมาก เช่น DeepSeek V3.2 อยู่ที่ $0.42/MTok ประหยัดกว่า OpenAI ถึง 85%

โครงสร้างพื้นฐานของระบบ

import requests
import json
from typing import List, Dict

classAITutor:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        self.conversation_history: List[Dict[str, str]] = []
        
    defadd_system_prompt(self, role: str):
        """กำหนดบทบาทของ AI ติวเตอร์"""
        self.conversation_history = [
            {
                "role": "system",
                "content": f"คุณคือติวเตอร์ภาษาไทยที่ใจดี "
                          f"มีความเชี่ยวชาญในการอธิบายเรื่อง{role} "
                          f"ให้เข้าใจง่าย พร้อมยกตัวอย่างประกอบ"
            }
        ]
        
    def chat(self, user_message: str) -> str:
        """ส่งข้อความและรับคำตอบพร้อมประวัติ"""
        self.conversation_history.append({
            "role": "user",
            "content": user_message
        })
        
        payload = {
            "model": "deepseek-chat",
            "messages": self.conversation_history,
            "temperature": 0.7,
            "max_tokens": 1000
        }
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=30
        )
        
        if response.status_code == 200:
            result = response.json()
            assistant_message = result["choices"][0]["message"]["content"]
            
            # บันทึกคำตอบลงประวัติ
            self.conversation_history.append({
                "role": "assistant",
                "content": assistant_message
            })
            
            return assistant_message
        else:
            raise Exception(f"API Error: {response.status_code}")


ใช้งาน

tutor = AITutor("YOUR_HOLYSHEEP_API_KEY")
tutor.add_system_prompt("คณิตศาสตร์ระดับมัธยม")
print(tutor.chat("สมการ x² - 5x + 6 = 0 มีวิธีแก้อย่างไร?"))

ระบบ Chat Memory สำหรับบทเรียนยาว

ถ้าบทเรียนยาวมาก ประวัติการสนทนาจะยาวเกินไปและทำให้ค่าใช้จ่ายสูง ผมเลยต้องสร้างระบบจัดการ memory ที่ฉลาดกว่านั้น

import requests
import json
from typing import List, Dict
from datetime import datetime

class SmartTutor:
    MAX_TOKENS = 6000  # จำกัดขนาด context window
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        self.conversation_history: List[Dict[str, str]] = []
        self.lesson_summary = ""  # สรุปบทเรียนก่อนหน้า
        
    def summarize_if_needed(self):
        """ถ้าประวัติยาวเกินไป ให้สรุปแล้วเก็บเฉพาะสาระสำคัญ"""
        estimated_tokens = sum(len(msg["content"]) // 4 
                              for msg in self.conversation_history)
        
        if estimated_tokens > self.MAX_TOKENS:
            # ขอ AI สรุปประวัติ
            summary_prompt = {
                "role": "user",
                "content": "สรุปสาระสำคัญของบทสนทนานี้ให้กระชับ "
                          "โดยเก็บคำถามที่ยังไม่ได้คำตอบและข้อสงสัยไว้ด้วย"
            }
            
            # ส่งเฉพาะประวัติที่มี
            payload = {
                "model": "deepseek-chat",
                "messages": self.conversation_history[-10:] + [summary_prompt],
                "temperature": 0.3
            }
            
            headers = {
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            }
            
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )
            
            if response.status_code == 200:
                result = response.json()
                self.lesson_summary = result["choices"][0]["message"]["content"]
                
                # เริ่มประวัติใหม่พร้อมสรุป
                self.conversation_history = [
                    {
                        "role": "system",
                        "content": f"สรุปบทเรียนก่อนหน้า:\n{self.lesson_summary}"
                    }
                ]
                
    def chat(self, user_message: str) -> str:
        self.summarize_if_needed()
        
        self.conversation_history.append({
            "role": "user",
            "content": user_message,
            "timestamp": datetime.now().isoformat()
        })
        
        payload = {
            "model": "deepseek-chat",
            "messages": self.conversation_history,
            "temperature": 0.7
        }
        
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=headers,
            json=payload,
            timeout=30
        )
        
        if response.status_code == 200:
            result = response.json()
            assistant_message = result["choices"][0]["message"]["content"]
            
            self.conversation_history.append({
                "role": "assistant",
                "content": assistant_message,
                "timestamp": datetime.now().isoformat()
            })
            
            return assistant_message
        else:
            raise Exception(f"Error {response.status_code}: {response.text}")


ทดสอบ

tutor = SmartTutor("YOUR_HOLYSHEEP_API_KEY")
response1 = tutor.chat("อธิบายเรื่อง สมการกำลังสอง")
response2 = tutor.chat("ยกตัวอย่างมา 3 ข้อ")

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

1. 401 Unauthorized - API Key ไม่ถูกต้อง

อาการ: ได้รับข้อผิดพลาด {"error": {"message": "Invalid API key", "type": "invalid_request_error"}}

วิธีแก้ไข: ตรวจสอบว่า API key ถูกต้องและไม่มีช่องว่างเพิ่มเข้ามา

# วิธีที่ผิด - มีช่องว่างผิดที่
headers = {
    "Authorization": f"Bearer  {self.api_key}",  # ผิด! มีช่องว่างเกิน
    "Content-Type": "application/json"
}


วิธีที่ถูก

headers = {
    "Authorization": f"Bearer {self.api_key}",  # ถูกต้อง
    "Content-Type": "application/json"
}


หรือตรวจสอบก่อนใช้งาน

def validate_api_key(api_key: str) -> bool:
    test_payload = {
        "model": "deepseek-chat",
        "messages": [{"role": "user", "content": "test"}],
        "max_tokens": 5
    }
    
    response = requests.post(
        "https://api.holysheep.ai/v1/chat/completions",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        },
        json=test_payload,
        timeout=10
    )
    
    return response.status_code == 200

2. ConnectionError: timeout - ประวัติการสนทนาส่งไปไม่หมด

อาการ: requests.exceptions.ConnectionError: HTTPSConnectionPool(host='api.holysheep.ai', port=443): Read timed out

วิธีแก้ไข: ตรวจสอบว่าส่ง history ทุกครั้ง และเพิ่ม timeout ให้เหมาะสม

# วิธีที่ผิด - ไม่ส่ง history
def chat_wrong(user_message: str):
    payload = {
        "model": "deepseek-chat",
        "messages": [{"role": "user", "content": user_message}],  # ไม่มี history!
        "temperature": 0.7
    }
    # จะทำให้ timeout เพราะ AI พยายามประมวลผลผิด


วิธีที่ถูก - ส่ง history พร้อม timeout ที่เหมาะสม

def chat_correct(user_message: str, history: List[Dict]):
    history.append({"role": "user", "content": user_message})
    
    payload = {
        "model": "deepseek-chat",
        "messages": history,
        "temperature": 0.7
    }
    
    response = requests.post(
        f"{self.base_url}/chat/completions",
        headers=self.headers,
        json=payload,
        timeout=60  # เพิ่ม timeout สำหรับ context ยาว
    )
    
    return response.json()["choices"][0]["message"]["content"]

3. Rate Limit Exceeded - เรียก API บ่อยเกินไป

อาการ: {"error": {"message": "Rate limit exceeded", "type": "rate_limit_exceeded"}}

วิธีแก้ไข: ใช้ระบบ cache และ debounce สำหรับการถามซ้ำ

from functools import lru_cache
import hashlib
import time

class CachedTutor:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        self.last_request_time = 0
        self.min_request_interval = 0.5  # รออย่างน้อย 0.5 วินาที
        
    def _rate_limit(self):
        """รอจนกว่าจะผ่านไปตาม interval ที่กำหนด"""
        elapsed = time.time() - self.last_request_time
        if elapsed < self.min_request_interval:
            time.sleep(self.min_request_interval - elapsed)
        self.last_request_time = time.time()
    
    @lru_cache(maxsize=100)
    def _get_cache_key(self, messages_tuple):
        """สร้าง cache key จากข้อความ"""
        return hashlib.md5(str(messages_tuple).encode()).hexdigest()
    
    def chat_cached(self, user_message: str, conversation_hash: str):
        # ตรวจสอบ rate limit
        self._rate_limit()
        
        # ตรวจสอบ cache
        cache_key = f"{conversation_hash}:{user_message}"
        if cache_key in self.chat_cached.cache_info().keys():
            return self._get_cached_response(cache_key)
        
        # เรียก API ตามปกติ
        response = self._call_api(user_message)
        self._save_to_cache(cache_key, response)
        
        return response

ราคาและการเลือกโมเดลที่เหมาะสม

สำหรับระบบติวเตอร์ที่ต้องสนทนายาว ควรเลือกโมเดลที่คุ้มค่าที่สุด: