บทนำ: ทำไม AI ถึงต้องมีความจำ?
สวัสดีครับ ผู้เขียนเป็นวิศวกร AI ที่ใช้งาน Trellis AI Agent มานานกว่า 2 ปี ในบทความนี้ผมจะอธิบายเรื่อง "กลไกการจดจำ" หรือ Memory Mechanism ของ AI Agent อย่างละเอียด เหมาะสำหรับผู้ที่เพิ่งเริ่มต้นและไม่มีพื้นฐานการเขียนโค้ดมาก่อน
คุณเคยสงสัยไหมครับว่า ทำไมบางครั้ง AI ถึงจำข้อมูลที่เราบอกไปก่อนหน้าได้ แต่บางครั้งก็ลืมเหมือนปลา? นั่นเป็นเพราะ AI Agent มีระบบความจำ 2 แบบที่ต้องทำงานร่วมกัน คือ "ความจำระยะสั้น" (Short-term Memory) และ "ความจำระยะยาว" (Long-term Memory) ให้ผมอธิบายให้เข้าใจง่ายๆ ครับ
ความจำระยะสั้นเปรียบเหมือนกระดาษทดที่ AI ใช้จดบันทึกข้อมูลในการสนทนาปัจจุบัน ส่วนความจำระยะยาวเปรียบเหมือนห้องสมุดที่เก็บความรู้และประสบการณ์ที่ผ่านมา การทำให้ทั้งสองระบบทำงานประสานกันอย่างลงตัว เป็นหัวใจสำคัญของ AI Agent ที่มีประสิทธิภาพสูง
สำหรับผู้ที่ต้องการทดลองใช้งาน AI Agent ผมแนะนำ
สมัครที่นี่ เพื่อรับเครดิตฟรีและทดลองใช้งาน API ราคาถูกมาก รองรับ WeChat และ Alipay ด้วยครับ
ความจำระยะสั้น (Short-term Memory) คืออะไร?
ความจำระยะสั้นเป็นข้อมูลที่ AI ใช้ในการสนทนาครั้งปัจจุบัน ลองนึกภาพเหมือนการคุยกับเพื่อนที่จำได้แค่สิ่งที่เราพูดในการสนทนานี้เท่านั้น พอจบการสนทนา เพื่อนก็จะลืมทุกอย่างไป
ในทางเทคนิค ความจำระยะสั้นจะถูกเก็บในรูปแบบ "Context Window" หรือพื้นที่สำหรับเก็บข้อความที่กำลังสนทนาอยู่ ข้อดีคือใช้งานง่าย ไม่ต้องตั้งค่าอะไรมาก แต่ข้อเสียคือถ้าข้อมูลมากเกินกว่าที่ Context จะรับได้ ข้อมูลเก่าจะถูกตัดทิ้งไป
ความจำระยะยาว (Long-term Memory) คืออะไร?
ความจำระยะยาวเปรียบเหมือนสมุดบันทึกส่วนตัวที่ AI สามารถเปิดอ่านย้อนหลังได้ตลอดเวลา ไม่ว่าจะผ่านไปกี่วันหรือกี่เดือน ข้อมูลสำคัญจะถูกเก็บรักษาไว้อย่างปลอดภัย
ระบบความจำระยะยาวมักจะใช้เทคโนโลยี "Vector Database" หรือฐานข้อมูลเวกเตอร์ เพื่อจัดเก็บข้อมูลในรูปแบบที่ AI สามารถค้นหาได้อย่างรวดเร็ว เมื่อต้องการข้อมูลเก่า AI จะทำการค้นหาและดึงข้อมูลที่เกี่ยวข้องมาผสมกับบทสนทนาปัจจุบัน
วิธีตั้งค่า Memory สำหรับ Trellis AI Agent
ตอนนี้เรามาลงมือทำกันเลยครับ ผมจะสอนทีละขั้นตอน ไม่ต้องกังวลถ้าคุณไม่เคยเขียนโค้ดมาก่อน เพราะผมจะอธิบายทุกอย่างให้เข้าใจง่ายๆ
ขั้นตอนแรก ให้คุณเปิดโปรแกรมจำลองการทำงาน Python ขึ้นมา (ถ้ายังไม่มี แนะนำให้ติดตั้ง Python จาก python.org ก่อนครับ) แล้วพิมพ์โค้ดตามด้านล่างนี้
# ติดตั้งไลบรารีที่จำเป็น
เปิด Terminal หรือ Command Prompt แล้วพิมพ์คำสั่งนี้:
pip install openai requests
นำเข้าไลบรารี
import openai
import requests
ตั้งค่าการเชื่อมต่อกับ HolySheep API
สมัครบัญชีได้ที่ https://www.holysheep.ai/register
openai.api_key = "YOUR_HOLYSHEEP_API_KEY"
openai.api_base = "https://api.holysheep.ai/v1"
print("เชื่อมต่อสำเร็จ! พร้อมสร้าง AI Agent แล้วครับ")
หลังจากรันโค้ดนี้แล้ว คุณจะเห็นข้อความ "เชื่อมต่อสำเร็จ!" ปรากฏบนหน้าจอ ถ้าเห็นแสดงว่าการตั้งค่าถูกต้องครับ
การสร้าง Short-term Memory (ความจำระยะสั้น)
การสร้างความจำระยะสั้นทำได้ง่ายมาก เพียงแค่ส่งข้อความทั้งหมดในการสนทนาปัจจุบันไปกับ Request ทุกครั้ง ผมจะสาธิตให้ดูครับ
# สร้างฟังก์ชันสำหรับส่งข้อความไปยัง AI
def send_message_to_ai(messages):
"""
messages คือลิสต์ของข้อความในรูปแบบ:
[
{"role": "user", "content": "ข้อความจากผู้ใช้"},
{"role": "assistant", "content": "ข้อความจาก AI"}
]
"""
response = openai.ChatCompletion.create(
model="gpt-4.1", # เลือกโมเดลที่ต้องการ
messages=messages,
temperature=0.7
)
return response.choices[0].message.content
ตัวอย่างการสนทนาแบบมีความจำระยะสั้น
conversation_history = []
รอบที่ 1: ผู้ใช้ทักทาย
user_message = "สวัสดีครับ ผมชื่อสมชาย"
conversation_history.append({"role": "user", "content": user_message})
response = send_message_to_ai(conversation_history)
print("AI:", response)
conversation_history.append({"role": "assistant", "content": response})
รอบที่ 2: ผู้ใช้ถามเรื่องที่พูดก่อนหน้า
user_message = "ผมชื่ออะไรนะ?"
conversation_history.append({"role": "user", "content": user_message})
response = send_message_to_ai(conversation_history)
print("AI:", response)
print("\n✅ AI จำได้ว่าคุณชื่อสมชาย!")
จากโค้ดด้านบน คุณจะเห็นว่าข้อมูลทุกอย่างถูกเก็บไว้ในตัวแปร "conversation_history" ซึ่งเป็นความจำระยะสั้น ทุกครั้งที่ส่งข้อความใหม่ เราจะส่งประวัติการสนทนาทั้งหมดไปด้วย
การสร้าง Long-term Memory (ความจำระยะยาว)
สำหรับความจำระยะยาว เราจะใช้วิธีเก็บข้อมูลสำคัญลงในฐานข้อมูล เมื่อจำเป็นต้องใช้จะดึงข้อมูลกลับมา ผมจะสาธิตด้วยวิธีง่ายๆ ก่อน แล้วค่อยไปสู่วิธีที่ซับซ้อนขึ้น
# สร้างระบบความจำระยะยาวแบบง่ายๆ
import json
from datetime import datetime
class SimpleMemory:
"""ระบบจัดเก็บความจำระยะยาวแบบง่าย"""
def __init__(self):
self.memory_file = "long_term_memory.json"
self.memories = self.load_memories()
def load_memories(self):
"""โหลดความจำจากไฟล์"""
try:
with open(self.memory_file, 'r', encoding='utf-8') as f:
return json.load(f)
except:
return {"facts": [], "preferences": {}}
def save_memory(self, key, value):
"""บันทึกความจำใหม่"""
self.memories[key] = {
"content": value,
"timestamp": datetime.now().isoformat()
}
with open(self.memory_file, 'w', encoding='utf-8') as f:
json.dump(self.memories, f, ensure_ascii=False, indent=2)
print(f"💾 บันทึกความจำ: {key}")
def get_memory(self, key):
"""ดึงความจำกลับมาใช้"""
return self.memories.get(key, None)
def get_all_memories(self):
"""ดึงความจำทั้งหมด"""
return self.memories
ทดสอบระบบความจำ
memory = SimpleMemory()
บันทึกข้อมูลสำคัญ
memory.save_memory("user_name", "สมชาย")
memory.save_memory("user_preference", "ชอบกาแฟมากกว่าชา")
memory.save_memory("important_fact", "แพ้เครื่องดื่มที่มีแล็กโทส")
print("\n📚 ความจำทั้งหมด:", memory.get_all_memories())
print("\n✅ ข้อมูลจะถูกเก็บไว้แม้ปิดโปรแกรมแล้วก็ตาม!")
เมื่อคุณรันโค้ดนี้ ระบบจะสร้างไฟล์ชื่อ "long_term_memory.json" ที่เก็บข้อมูลสำคัญไว้ แม้คุณจะปิดโปรแกรมแล้วเปิดใหม่ ข้อมูลเหล่านี้ก็ยังอยู่ครับ
การรวม Short-term และ Long-term Memory เข้าด้วยกัน
นี่คือหัวใจสำคัญของระบบ Memory ที่ดี การทำให้ทั้งสองระบบทำงานประสานกันอย่างลงตัว ผมจะสร้างตัวอย่างที่สมบูรณ์ให้ดูครับ
# ระบบ Memory แบบครบวงจร
class HybridMemory:
"""ระบบความจำแบบผสม - รวม Short-term และ Long-term"""
def __init__(self):
self.long_term = SimpleMemory() # ความจำระยะยาว
self.short_term = [] # ความจำระยะสั้น
self.max_short_term = 10 # จำนวนข้อความสูงสุดในความจำระยะสั้น
def add_to_short_term(self, role, content):
"""เพิ่มข้อความในความจำระยะสั้น"""
self.short_term.append({"role": role, "content": content})
# ถ้าเกินขีดจำกัด ให้ลบข้อความเก่าที่สุด
if len(self.short_term) > self.max_short_term:
self.short_term.pop(0)
def save_important_to_long_term(self, key, value):
"""บันทึกข้อมูลสำคัญลงความจำระยะยาว"""
self.long_term.save_memory(key, value)
def get_context_for_ai(self):
"""รวมความจำทั้งหมดเพื่อส่งให้ AI"""
context = []
# ดึงข้อมูลสำคัญจากความจำระยะยาว
all_memories = self.long_term.get_all_memories()
if all_memories:
memory_summary = "ข้อมูลที่คุณควรรู้เกี่ยวกับผู้ใช้:\n"
for key, value in all_memories.items():
if isinstance(value, dict):
memory_summary += f"- {key}: {value['content']}\n"
context.append({"role": "system", "content": memory_summary})
# เพิ่มความจำระยะสั้น
context.extend(self.short_term)
return context
def chat(self, user_message):
"""สนทนากับ AI โดยใช้ความจำทั้งสองแบบ"""
# เพิ่มข้อความผู้ใช้ในความจำระยะสั้น
self.add_to_short_term("user", user_message)
# รวม context จากทั้งสองระบบ
messages = self.get_context_for_ai()
# ส่งให้ AI
response = send_message_to_ai(messages)
# เพิ่ม response ของ AI ในความจำระยะสั้น
self.add_to_short_term("assistant", response)
return response
ทดสอบระบบผสม
hybrid = HybridMemory()
บันทึกข้อมูลสำคัญล่วงหน้า
hybrid.save_important_to_long_term("ชื่อผู้ใช้", "สมชาย")
hybrid.save_important_to_long_term("งบประมาณ", "50,000 บาทต่อเดือน")
สนทนาปกติ
print(hybrid.chat("สวัสดีครับ อยากซื้อคอมพิวเตอร์ใหม่"))
print(hybrid.chat("จำได้ไหมว่าผมชื่ออะไร?"))
print("\n🔗 AI รวมข้อมูลจากทั้ง Short-term และ Long-term Memory!")
การตั้งค่า Context Window อย่างเหมาะสม
Context Window คือพื้นที่สำหรับเก็บข้อมูลในการสนทนาปัจจุบัน ซึ่งแต่ละโมเดลมีขีดจำกัดต่างกัน โดยทั่วไปแล้ว:
- GPT-4.1 รองรับ Context สูงสุด 128,000 คำ
- Claude Sonnet 4.5 รองรับ Context สูงสุด 200,000 คำ
- Gemini 2.5 Flash รองรับ Context สูงสุด 1 ล้านคำ
- DeepSeek V3.2 รองรับ Context สูงสุด 128,000 คำ
ผมเลือกใช้
HolySheep AI เพราะราคาถูกมาก เช่น DeepSeek V3.2 ราคาเพียง $0.42 ต่อล้านคำ ประหยัดได้มากกว่า 85% เมื่อเทียบกับบริการอื่น รวมถึงรองรับ WeChat และ Alipay ด้วยครับ
เทคนิคการปรับปรุง Memory ให้มีประสิทธิภาพสูงสุด
จากประสบการณ์ที่ผมใช้งานมา มีเทคนิคสำคัญที่ช่วยให้ระบบ Memory ทำงานได้ดีขึ้นมาก
เทคนิคแรกคือ "การบีบอัดข้อมูล" อย่าส่งข้อความทั้งหมดไปทุกครั้ง ให้สรุปเนื้อหาสำคัญแทน เช่น แทนที่จะส่งข้อความ 100 ข้อความก่อนหน้า ลองสรุปเหลือแค่ 5-10 ประเด็นสำคัญ
เทคนิคที่สองคือ "การจัดลำดับความสำคัญ" ให้ AI ตัดสินใจว่าข้อมูลไหนสำคัญต้องเก็บลง Long-term Memory และข้อมูลไหนเป็นแค่บทสนทนาธรรมดาที่ลบทิ้งได้
เทคนิคที่สามคือ "การแบ่งหมวดหมู่" จัดเก็บความจำเป็นหมวดหมู่ เช่น ข้อมูลส่วนตัว ความชอบ ประวัติการทำธุรกรรม เพื่อให้ค้นหาได้ง่ายขึ้น
เทคนิคที่สี่คือ "การกำหนดอายุของข้อมูล" ความจำบางอย่างควรมีวันหมดอายุ ถ้าไม่ได้ใช้นานเกิน 30 วัน อาจลบทิ้งหรือถามผู้ใช้ว่ายังต้องการเก็บไว้ไหม
ตัวอย่างโปรเจกต์จริง: ระบบแชทบอทที่จำลูกค้า
ให้ผมแสดงตัวอย่างโปรเจกต์จริงที่ใช้ระบบ Memory แบบครบวงจรครับ โปรเจกต์นี้เป็นระบบแชทบอทสำหรับร้านค้าออนไลน์ที่สามารถจำลูกค้าประจำได้
# โปรเจกต์จริง: ระบบแชทบอทสำหรับร้านค้าออนไลน์
class CustomerChatBot:
"""แชทบอทสำหรับร้านค้าออนไลน์พร้อมระบบจดจำลูกค้า"""
def __init__(self, customer_id):
self.customer_id = customer_id
self.memory_file = f"customer_{customer_id}_memory.json"
self.conversation = []
self.load_customer_data()
def load_customer_data(self):
"""โหลดข้อมูลลูกค้าจากไฟล์"""
try:
with open(self.memory_file, 'r', encoding='utf-8') as f:
data = json.load(f)
self.name = data.get('name', 'ลูกค้า')
self.preferences = data.get('preferences', [])
self.order_history = data.get('order_history', [])
self.notes = data.get('notes', '')
except:
self.name = 'ลูกค้าใหม่'
self.preferences = []
self.order_history = []
self.notes = ''
def save_customer_data(self):
"""บันทึกข้อมูลลูกค้าลงไฟล์"""
data = {
'name': self.name,
'preferences': self.preferences,
'order_history': self.order_history,
'notes': self.notes
}
with open(self.memory_file, 'w', encoding='utf-8') as f:
json.dump(data, f, ensure_ascii=False, indent=2)
def get_system_prompt(self):
"""สร้าง prompt สำหรับ AI โดยรวมข้อมูลลูกค้า"""
prompt = f"""คุณคือพนักงานขายในร้านค้าออนไลน์
ชื่อลูกค้า: {self.name}
สินค้าที่สนใจ: {', '.join(self.preferences) if self.preferences else 'ยังไม่มีข้อมูล'}
ประวัติการสั่งซื้อ: {', '.join(self.order_history) if self.order_history else 'ยังไม่มีการสั่งซื้อ'}
โน้ตพิเศษ: {self.notes}
กรุณาตอบลูกค้าอย่างเป็นมิตร และแนะนำสินค้าที่เหมาะสม"""
return prompt
def process_order(self, order):
"""บันทึกการสั่งซื้อ"""
self.order_history.append(order)
self.save_customer_data()
return f"📦 บันทึกการสั่งซื้อ: {order} แล้วครับ"
def add_preference(self, item):
"""เพิ่มสินค้าที่สนใจ"""
if item not in self.preferences:
self.preferences.append(item)
self.save_customer_data()
return f"✅ บันทึกว่าคุณสนใจ: {item}"
def chat(self, message):
"""รับข้อความและตอบกลับ"""
# เพิ่มข้อความในบทสนทนา
self.conversation.append({"role": "user", "content": message})
# สร้าง context สำหรับ AI
messages = [
{"role": "system", "content": self.get_system_prompt()}
]
messages.extend(self.conversation[-10:]) # ใช้แค่ 10 ข้อความล่าสุด
# ส่งให้ AI
response =
แหล่งข้อมูลที่เกี่ยวข้อง
บทความที่เกี่ยวข้อง