ออกแบบความจำ AI
ให้เหมือนความจำคน

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

ขุดลงไปถึงเจอ ตัวข้อมูลเขียนลงกราฟความจำชื่อ jizo ครบทุกตอน แต่ตอน "อ่าน" ระบบไปเปิดอีกกราฟหนึ่ง (default_db) ที่ว่างเปล่า เขียนห้องหนึ่ง อ่านอีกห้องหนึ่ง บทเรียนแรกเลยคือ memory ไม่ได้อยู่ที่ "เก็บ" แต่อยู่ที่ "ดึงกลับมาให้ตรง" ระบบที่เก็บเก่งแต่ดึงพลาด มีค่าเท่ากับไม่มี memory เลย

พอกลับมาออกแบบใหม่ วิธีคิดที่ช่วยได้มากที่สุดคือมองความจำของ AI เหมือนความจำของคนเรา เพราะคนก็ไม่ได้จำทุกอย่าง เรามีของที่อยู่ในหัวตอนนี้ มีของที่เก็บไว้แล้วนึกออกตอนที่เกี่ยว มีการคัดว่าอะไรควรจำ และมีการจัดระเบียบความจำเก่าอยู่เรื่อย ๆ ระบบ memory ที่ดีของ AI ก็ลอกโครงสี่อย่างนี้มาได้ตรง ๆ

บทความนี้มีสามช่วง เริ่มจาก ทำไม AI ถึงไม่มีความจำ และปัญหาตัวจริงอยู่ตรงไหน ต่อด้วย ออกแบบความจำ AI แบบเดียวกับความจำคน แล้วปิดด้วย หลักที่ทำให้ memory เชื่อถือได้ (กรณีที่เล่ามาตอนต้นมาจากระบบความจำของ fleet เราเอง)

ช่วงที่ 1ทำไม AI ถึงไม่มีความจำ และปัญหาตัวจริงอยู่ตรงไหน

ตัวโมเดลถือของไว้ได้แค่ "ตอนนี้"

เรื่องที่หลายคนเข้าใจผิด คือคิดว่าโมเดลภาษา "จำ" สิ่งที่เคยคุยได้เอง จริง ๆ แล้วมันไม่จำอะไรเลย พอจบรอบคุยหนึ่ง ทุกอย่างก็หายเกลี้ยง รอบถัดไปเริ่มจากศูนย์เหมือนไม่เคยเจอกัน สิ่งที่เราเห็นว่า AI "จำได้" จริง ๆ แล้วคือมีคนเอาเรื่องเก่ากลับเข้าไปป้อนใหม่ทุกครั้ง ยัดเข้าไปใน context window ก่อนมันจะตอบ

ตรงนี้เหมือน working memory ของคนพอดี เราถือของไว้ในหัวได้แค่ไม่กี่อย่างในแต่ละช่วง พอเปลี่ยนเรื่องของเดิมก็หลุด คนเลยต้องมีความจำระยะยาวไว้ข้างนอกหัว ค่อยดึงกลับมาตอนต้องใช้ memory ของ agent ก็เหมือนกัน มันไม่ใช่ความสามารถของตัวโมเดล แต่เป็นระบบที่เราต้องสร้างครอบมันไว้ข้างนอก

ปัญหาตัวจริงอยู่ที่ "ดึงกลับ" ไม่ใช่ "เก็บ"

พอเข้าใจตรงนี้ คนส่วนใหญ่ก็ไปโฟกัสที่การเก็บ หาที่จดให้ครบ ซึ่งเป็นส่วนที่ง่ายที่สุด ที่ยากจริงคือตอนดึงกลับ เพราะของที่เก็บไว้เยอะขึ้นเรื่อย ๆ แต่ context window มีพื้นที่จำกัด จะยัดทุกอย่างกลับเข้าไปก็ไม่ได้

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

ช่วงที่ 2ออกแบบความจำ AI แบบเดียวกับความจำคน

หลักมีข้อเดียว แยก memory เป็นชั้นตามว่าอะไร "ต้องเห็นทุกครั้ง" กับอะไร "ค่อยดึงตอนเกี่ยวข้อง" แล้วมีประตูคัดของเข้า กับพิธีจัดระเบียบของเก่า โครงสี่ส่วนนี้ลอกมาจากความจำคนตรง ๆ ที่เหลือเป็นแค่วิธีทำให้มันเกิดขึ้นจริง

ชั้นที่ 1 สารบัญแบนที่โหลดทุกครั้ง คือความรู้ติดตัว

ของที่ต้องรู้ทุกรอบไม่ว่าคุยเรื่องอะไร เก็บเป็นไฟล์ข้อความสั้น ๆ หนึ่งข้อเท็จจริงต่อหนึ่งไฟล์ แล้วมีสารบัญบรรทัดเดียวต่อไฟล์รวมไว้ที่เดียว ชั้นนี้เหมือนความรู้ที่เราจำขึ้นใจ หยิบใช้ได้ทันทีไม่ต้องนึก ตั้งใจให้เรียบและถูก ไม่ต้องมีฐานข้อมูลอะไรหรูหรา คนก็อ่านออก แก้มือได้ เปิดมาก็เห็นทั้งหมดในรอบเดียว ของเราคือไฟล์ MEMORY.md ที่เป็นสารบัญ กับไฟล์ข้อเท็จจริงแยกไฟล์ละข้อวางข้าง ๆ กัน

ชั้นที่ 2 ความจำแบบเหตุการณ์ ที่ดึงตอนเกี่ยว

ของที่ไม่ต้องเห็นทุกครั้ง แต่อยากให้โผล่มาตอนคุยเรื่องที่เกี่ยว เก็บเป็นตอน ๆ ตามเหตุการณ์ แล้วใช้การวัดความใกล้เคียงทางความหมายดึงกลับมา ชั้นนี้คือความจำระยะยาวแบบ episodic ของคน พอกำลังเจอสถานการณ์ไหน เรื่องเก่า ๆ ที่เกี่ยวกับเรื่องนั้นก็ลอยขึ้นมาเอง โดยไม่ต้องลากความจำทั้งหมดกลับมาพร้อมกัน ของเราใช้ Graphiti เก็บความจำเป็นกราฟตามเวลา ลงใน FalkorDB แล้วดึงกลับด้วย embedding bge-m3 ตอน recall ใช้แค่ embedding กับกราฟ ไม่ต้องเรียกโมเดลใหญ่ นี่คือชั้นที่เคสตอนต้นเรื่องพัง และเป็นชั้นที่ต้องตรวจ recall ให้ผ่านจริงก่อนไว้ใจ

ประตูคัดเข้า เพราะคนไม่ได้จำทุกอย่าง

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

1. ซ้ำกับของที่จำไว้แล้วไหม ถ้าใช่ ไปแก้ของเดิม ไม่สร้างใหม่
2. เดาเอาจากโค้ดหรือประวัติงานได้อยู่แล้วไหม ถ้าใช่ ไม่ต้องจำซ้ำ
3. จริงเฉพาะรอบคุยนี้ไหม ถ้าใช่ ปล่อยให้มันหายไปกับรอบ
4. อีกอาทิตย์เดียวก็เก่าแล้วไหม ถ้าใช่ อย่าเพิ่งฝังเป็นความจำถาวร
5. เป็นสิ่งที่จะกันพลาดครั้งหน้าได้ไหม ถ้าใช่ อันนี้แหละควรจำที่สุด

ของที่ผ่านประตูนี้ส่วนใหญ่จะเป็นแบบเดียวกัน คือ "เคยพลาดแบบนี้ คราวหน้าอย่าทำซ้ำ" ส่วนของที่แค่บันทึกว่าวันนี้ทำอะไร ปล่อยให้ประวัติงานจดไปก็พอ ไม่ต้องเปลือง memory

พิธีจัดระเบียบ เหมือนสมองตอนหลับ

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

โครงสี่ส่วนนี้ใครก็วางตามได้ ส่วนที่เราลงแรงทำต่อ คือทำให้ประตูคัดเข้ากับการตรวจ recall ทำงานเองอัตโนมัติ แนวคิดคือ ตรึงหน้าตาของแต่ละชั้นให้ตายตัว ส่วนเครื่องมือข้างในเปลี่ยนได้ วันนี้ใช้ฐานข้อมูลแบบกราฟ พรุ่งนี้จะสลับเป็นอย่างอื่นก็ไม่กระทบโครง

ช่วงที่ 3หลักที่ทำให้ memory เชื่อถือได้

วางโครงได้แล้ว ยังเหลือกับดักที่ทำให้ memory ดู "ใช้ได้" ทั้งที่จริงพัง สามข้อนี้คือสิ่งที่เราเจอกับตัว

recall ที่คืนค่าว่างเงียบ ๆ แย่กว่าไม่มี memory

ถ้า memory พังแบบมี error เด้งขึ้นมา ยังนับว่าโชคดี เพราะรู้ตัวทันที แต่เคสที่เจอร้ายกว่านั้น ทุกอย่างตอบกลับมาปกติ ระบบบอกว่าบันทึกสำเร็จ ดึงสำเร็จ แค่ของที่ดึงมาว่างเปล่า ความว่างเปล่าแบบเงียบ ๆ นี้อันตราย เพราะทำให้เราวางใจว่ามี memory แล้ว ทั้งที่จริงไม่มี แล้วก็สร้างของอื่นทับไปเรื่อย ๆ บนฐานที่ไม่มีอยู่จริง

อย่าเชื่อ "บันทึกสำเร็จ" ให้ตรวจว่าดึงกลับมาเจอจริง

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

ไม่มีประตูคัด memory จะบวมจนของสำคัญจม

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

เอาไปใช้กับงานแบบไหน แล้วเริ่มยังไง

โครงนี้ใช้ได้กับ ผู้ช่วย AI ส่วนตัว ที่ต้องจำเรื่องข้ามวันข้ามสัปดาห์ chatbot ดูแลลูกค้า ที่ต้องจำว่าลูกค้าคนนี้เคยเจอปัญหาอะไร ชอบแบบไหน agent ที่ทำงานยาว ๆ ที่ context window เต็มเร็วจนต้องเลือกว่าจะอุ้มอะไรไว้ หรือ ทีมที่มี AI หลายตัว ที่ต้องแชร์ความจำกันโดยไม่เหยียบกันเอง

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