หน่วยความจำของเอเจนต์ AI: วิธีสร้างเอเจนต์ AI ที่มีบริบทต่อเนื่อง

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

ทุกวันนี้ หน่วยความจำของเอเจนต์ AI ก็มีการพาเดินไปที่เครื่องพิมพ์แบบไม่มีวันจบในแบบของตัวเองอยู่ Charles Packer ซีอีโอของ Letta กล่าวใน The New Stack ว่าเบนช์มาร์กด้านหน่วยความจำนั้นอิ่มตัวแล้ว เพราะวัดแค่การเรียกคืนข้อมูล ซึ่งเขามองว่าเป็นปัญหาที่แก้ได้แล้ว ปัญหาที่ยังเปิดอยู่คือการทำให้เอเจนต์ทำงานได้ดีขึ้นผ่านบริบทที่เอเจนต์เก็บไว้ โดยไม่ต้องฝึกโมเดลใหม่

Sarah Wooders ผู้ร่วมก่อตั้งของเขาเปรียบเรื่องนี้กับการเริ่มงานใหม่—เบนช์มาร์กป้อนบริบททั้งหมดที่เอเจนต์ต้องการให้—งานแล้วงานเล่าที่ไม่เกี่ยวข้องกัน ซึ่งไม่เหมือนกับวิธีที่คนทำงานเลย พนักงานใหม่อาจต้องมีคนพาเดินไปที่เครื่องพิมพ์ แต่เมื่อทำงานมาสามปีแล้ว คุณก็คงหวังว่าจะส่งบรีฟสั้น ๆ เพียงบรรทัดเดียวให้เขาได้โดยไม่ต้องลุกจากโต๊ะ

นั่นคือมาตรฐานที่เราควรมุ่งไปให้ถึง และเป็นเป้าหมายเบื้องหลัง Brain ระบบหน่วยความจำที่พัฒนาตัวเองได้ของเราสำหรับ Perplexity Computer ซึ่งจัดระเบียบงานและการแก้ไขในอดีตให้เป็นวิกิความรู้ที่พัฒนาอย่างต่อเนื่อง

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

หน่วยความจำของเอเจนต์ AI คืออะไร?

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

สิ่งที่เปิดตัวภายใต้ชื่อนี้ส่วนใหญ่จะจดจำผู้ใช้ ทั้งความชอบ รายชื่อผู้ติดต่อ และบทบาทของคุณ หรือข้อเท็จจริงที่ว่าคุณต้องการไฟล์ PDF มากกว่า PNG นั่นคือครึ่งที่ง่าย

เมื่อเราสร้าง Brain ระบบหน่วยความจำเบื้องหลัง Perplexity Computer เรามุ่งเน้นที่ตัวงานเอง แนวทางใดที่ประสบความสำเร็จ? แหล่งข้อมูลใดที่ทำให้เสียเวลาไปยี่สิบนาที? คุณต้องแก้ไขอะไรบ้างหลังจากเอเจนต์ประกาศว่าทำงานเสร็จแล้ว? ประวัติเหล่านั้นช่วยให้งานถัดไปมีจุดเริ่มต้นที่ดีกว่า

Brain จัดเก็บข้อมูลนี้เป็นไฟล์ในแซนด์บ็อกซ์ของเอเจนต์ โดยจัดระเบียบเป็นสามชั้น:

• sessions/ เก็บทรานสคริปต์ดิบและบทสรุปของทรานสคริปต์เหล่านั้น
• notes/ เก็บข้อมูลที่กลั่นกรองแล้วโดยจัดตามหัวข้อ
• knowledge/ เก็บตัววิกิเอง ได้แก่ หน้า Markdown ที่ลิงก์ถึงกันเกี่ยวกับบุคคล โปรเจกต์ และแนวคิดต่าง ๆ

ทั้งหมดนี้ไม่ได้ดีขึ้นเองโดยอัตโนมัติ ในช่วงกลางคืน เอเจนต์เบื้องหลังที่เราเรียกว่า “Dream” จะอ่านเซสชันของวันนั้น สรุปเนื้อหา และปรับปรุงวิกิในทุกจุดที่ภาพรวมเปลี่ยนไป เราจัดเตรียมและตรวจสอบการแก้ไขเหล่านั้นก่อนคอมมิตผ่าน Git เพื่อให้มี diff ไว้ตรวจสอบเมื่อมีบางอย่างดูผิดปกติ

สิ่งนี้ทำให้เอเจนต์ทำงานได้ดีขึ้นหรือไม่? ในการประเมินแบบจับคู่ระยะเวลา 30 วันของเรา เซสชันที่เปิดใช้ Brain มีความถูกต้องเพิ่มขึ้น 9.3 จุดเปอร์เซ็นต์ และการเรียกคืนข้อมูลเพิ่มขึ้น 8.9 จุด ขณะที่ใช้โทเค็นน้อยลงประมาณ 15%

ขยาย

ที่มา: X

หน่วยความจำของเอเจนต์มีประเภทใดบ้าง?

หน่วยความจำแบ่งออกเป็นสองประเภทกว้าง ๆ และการแบ่งนี้ก็คล้ายกับที่คุณใช้กับคน คือสิ่งที่คุณกำลังจดจ่ออยู่ในหัวตอนนี้ และสิ่งที่คุณจะยังรู้อยู่ในเดือนหน้า

หน่วยความจำระยะสั้น

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

คุณอาจเห็นสิ่งนี้ถูกเรียกว่าหน่วยความจำใช้งาน (working memory) ด้วย สำหรับ LLM หน้าต่างบริบท (context window) จะเก็บข้อมูลที่พร้อมใช้งานระหว่างการเรียกโมเดลแต่ละครั้ง แอปพลิเคชันอาจเก็บสถานะงานเพิ่มเติมไว้ และตัดสินใจว่าจะส่งส่วนใดให้โมเดลในแต่ละขั้นตอน

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

หน่วยความจำระยะยาว

หน่วยความจำระยะยาวทำให้ข้อมูลพร้อมใช้งานข้ามเซสชัน งานวิจัย CoALA ได้ยืมหมวดหมู่สามประเภทมาจากวิทยาศาสตร์การรู้คิด ทำให้ผู้สร้างเอเจนต์มีคำศัพท์สำหรับอธิบายประสบการณ์และความรู้เชิงปฏิบัติ:

• หน่วยความจำเชิงเหตุการณ์ (Episodic) คือสิ่งที่เกิดขึ้น: ซึ่งรวมถึงเซสชันที่ผ่านมา ขั้นตอนที่เอเจนต์ดำเนินการ และผลลัพธ์ที่ได้ ใน Brain sessions/ ให้ประวัตินี้ผ่านทรานสคริปต์ดิบและบทสรุป
• หน่วยความจำเชิงความหมาย (Semantic) คือสิ่งที่เอเจนต์ถือว่าเป็นความจริง: ซึ่งอาจเป็นข้อเท็จจริงเกี่ยวกับผู้ใช้ โปรเจกต์ และโลกของพวกเขา ที่กลั่นกรองมาจากบทสนทนา วิกิ knowledge/ ของ Brain เก็บข้อมูลประเภทนี้ไว้ พร้อมลิงก์กลับไปยังหลักฐาน
• หน่วยความจำเชิงกระบวนการ (Procedural) คือวิธีทำสิ่งต่าง ๆ: ได้แก่ พรอมต์ เวิร์กโฟลว์ที่ใช้ซ้ำได้ และ Skill ที่ Perplexity สร้างขึ้น เพื่อให้เอเจนต์มีคำสั่งและเครื่องมือที่งานนั้นต้องการ คุณอาจมีสิ่งเหล่านี้อยู่แล้วบางส่วนโดยไม่ได้เรียกมันว่าหน่วยความจำ

งานที่น่าสนใจเกิดขึ้นระหว่างชั้นต่าง ๆ เซสชันหนึ่งบันทึกว่าคุณปฏิเสธไฟล์ PNG คำสั่งของคุณให้ใช้ PDF จะกลายเป็นความชอบที่เอเจนต์นำไปใช้ต่อได้ การแก้ไขกระบวนการส่งออกจะกลายเป็นสิ่งที่เอเจนต์ทำตามได้ในครั้งต่อไป

การแปลงจาก “สิ่งนี้เกิดขึ้น” ไปเป็น “สิ่งนี้เป็นความจริง” แล้วไปเป็น “นี่คือวิธีที่เราทำ” เป็นส่วนหนึ่งของปัญหาการเรียนรู้ที่เราพูดถึงตอนต้น และเป็นจุดที่การทำงานช่วงกลางคืนของเอเจนต์ Dream ของ Brain ทุ่มเทความพยายามลงไป

สมมติว่ามีคนอุ่นปลาในไมโครเวฟในครัวส่วนกลาง มีคนบ่น มีคนเปิดหน้าต่าง ในที่สุดก็มีป้ายติดขึ้นมาว่า: ห้ามอุ่นปลา

หกเดือนต่อมา ผู้กระทำผิดย้ายออกไปแล้ว แต่ป้ายยังอยู่ นั่นคือความคงอยู่ คุณอธิบายประเภทของหน่วยความจำได้ผ่านสิ่งที่ยังคงอยู่:

• หน่วยความจำใช้งานคือสิ่งที่คุณคอยจดจ่ออยู่ขณะทำอาหารกลางวัน เช่น ซุปที่ต้องคน
• หน่วยความจำเชิงเหตุการณ์คือเหตุการณ์เรื่องปลา กลิ่นที่ตามทุกคนออกไปถึงทางเดิน
• หน่วยความจำเชิงความหมายคือความรู้ที่คุณได้จากเหตุการณ์นั้น—การอุ่นปลาซ้ำอาจทิ้งกลิ่นค้างไว้ในครัวส่วนกลาง
• หน่วยความจำเชิงกระบวนการคือคำสั่งที่กำหนดสิ่งที่จะเกิดขึ้นต่อไป ห้ามอุ่นปลาในไมโครเวฟที่นี่ ป้ายนี้ช่วยให้คนที่ไม่รู้เรื่องเหตุการณ์ทั้งหมดสามารถทำตามกฎได้

ยังมีความแตกต่างอีกข้อหนึ่ง เพราะมันเปลี่ยนสิ่งที่เรากำลังสร้าง แบบสำรวจงานวิจัยที่เผยแพร่ครั้งแรกในเดือนธันวาคม 2025 ชื่อ Memory in the Age of AI Agents ระบุว่าการแบ่งเป็นระยะสั้นกับระยะยาวยังไม่เพียงพอ—งานนี้จึงจัดประเภทหน่วยความจำตามรูปแบบด้วย:

• ระดับโทเค็น: คือเนื้อหาที่ชัดแจ้งซึ่งเอเจนต์อ่าน เช่น ไฟล์ ระเบียนที่จัดเก็บไว้ และชิ้นข้อมูลที่ดึงมา
• เชิงพารามิเตอร์: คือข้อมูลที่เข้ารหัสอยู่ในน้ำหนักที่โมเดลเรียนรู้ การอัปเดตข้อมูลนี้ต้องอาศัยการฝึกหรือวิธีการแก้ไขโมเดล
• แบบแฝง: คือข้อมูลที่เก็บไว้ในตัวแทนภายใน (internal representations) โดยไม่ได้เขียนออกมาเป็นข้อความที่อ่านได้

ในที่นี้เรามุ่งเน้นที่หน่วยความจำระดับโทเค็น ซึ่งก็คือข้อมูลที่จัดเก็บไว้ภายนอกโมเดลและถูกอ่านเข้าสู่บริบทของโมเดลเมื่อจำเป็น วิกิ Markdown ของ Brain ก็เป็นตัวอย่างหนึ่ง

ขยาย

เมื่อเราอัปเดตหน้าหนึ่ง เราเปลี่ยนสิ่งที่เอเจนต์อ่านได้ในงานถัดไป แต่น้ำหนักพื้นฐานของเอเจนต์ยังคงเหมือนเดิม นั่นคือประเด็นของ Packer ในตอนต้น: การพัฒนาให้ดีขึ้นผ่านบริบทที่เอเจนต์เก็บไว้ โดยไม่ต้องฝึกใหม่

หน่วยความจำแต่ละประเภทของเอเจนต์ทำงานร่วมกันอย่างไร?

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

ในที่นี้ ความคงอยู่ (persistence) เป็นตัวกำหนดว่าอะไรยังคงพร้อมใช้งานหลังจากบทสนทนาจบลง ขณะที่การดึงข้อมูล (retrieval) เป็นตัวกำหนดว่าเอเจนต์จะได้เห็นข้อมูลนั้นอีกหรือไม่

ใน Brain เรารักษาเส้นทางจากบทเรียนย้อนกลับไปยังหลักฐานไว้ สมมติว่าคุณขอให้ Computer ทำโปรเจกต์ต่อจากสัปดาห์ที่แล้ว:

• ดัชนีของ Brain จะบอกเอเจนต์ว่ามีหน้าหน่วยความจำใดบ้าง และจะหาได้จากที่ไหน
• Brain เปิดหน้าโปรเจกต์เพื่ออ่านการตัดสินใจและคำสั่งที่บันทึกไว้
• หากโน้ตระบุว่าคุณปฏิเสธแนวทางหนึ่ง เอเจนต์สามารถติดตามการอ้างอิงย้อนกลับไปยังบทสนทนาและตรวจสอบเหตุผลได้

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

เรายังได้ทดสอบว่าเอเจนต์ได้ประโยชน์อะไรจากความสามารถในการสำรวจไฟล์ ในเบนช์มาร์กภายในที่มีคำถามเกี่ยวกับเอกสารทางการเงิน 150 ข้อ เอเจนต์สำรวจที่ใช้เครื่องมือไฟล์มาตรฐานได้คะแนนคำตอบ 0.627 เทียบกับประมาณ 0.37 สำหรับการค้นหาเชิงความหมายบนคลังข้อมูลชุดเดียวกัน

ขยาย

ที่มา: X

จะปรับปรุงหน่วยความจำของเอเจนต์ AI ได้อย่างไร?

งานวิจัยของ Orogat และ Mansour เมื่อเดือนพฤษภาคม 2026 ระบุความล้มเหลวที่เกิดซ้ำสี่ประการในหน่วยความจำของเอเจนต์ ได้แก่ คลังข้อมูลขยายตัวไม่หยุด ความเชื่อที่ล้าสมัยไม่ได้รับการแก้ไข ข้อมูลถูกลืมเมื่อพื้นที่เต็ม และการดึงข้อมูลเป็นเพียงการอ่านโดยไม่ได้เรียนรู้อะไรจากการเข้าถึงครั้งนั้น

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

เลือกสรรสิ่งที่จะจดจำ

เมื่อหน่วยความจำที่ “ไม่ดี” เข้ามาแล้ว ทุกขั้นตอนต่อจากนั้นจะรับสืบทอดมันไปด้วย

Workday AI Research ทดสอบแนวทางแบบเลือกสรรกับหน่วยความจำที่เป็นตัวเลือกประมาณ 1,500 รายการจากเบนช์มาร์ก LoCoMo โดยตั้งคำถามห้าข้อก่อนตัดสินใจเก็บรายการใดไว้:

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

มีเพียงคำถามแรกเท่านั้นที่ต้องเรียกใช้โมเดล อีกสี่ข้อทำงานเป็นกฎโดยใช้เวลารวมกันไม่ถึง 65 มิลลิวินาที วิธีนี้ให้ความแม่นยำสูงขึ้น 12% ในการตัดสินใจว่าจะเก็บหรือทิ้ง ขณะที่ยังคงรักษาหน่วยความจำที่เกี่ยวข้องไว้ได้ 97%

ปัจจัยที่มีส่วนมากที่สุดคือคำถามสุดท้าย—หากตัดการแยกแยะระหว่างข้อมูลที่คงทนกับข้อมูลชั่วคราวออกไป คุณภาพของการตัดสินใจจะลดลงประมาณ 18%

แก้ไขคำตอบโดยไม่สูญเสียประวัติ

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

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

ลืมอย่างตั้งใจ

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

กลับมาที่ครัวส่วนกลาง หลังจากผ่านไปหกเดือน ไม่มีใครสนใจแล้วว่าใครอุ่นปลาในไมโครเวฟ หรือหน้าต่างเปิดค้างไว้นานแค่ไหน แต่ป้ายนั้นก็ยังมีหน้าที่อยู่

เมื่อคนถัดไปมาทำอาหารกลางวัน กฎก็จะยังอยู่ให้เห็น คุณแค่เก็บถาวรเรื่องร้องเรียนไว้

การตรวจสอบความใหม่และประเภทข้อมูลของ Workday เริ่มต้นก่อนการจัดเก็บ เพื่อกรองว่าอะไรสมควรกลายเป็นหน่วยความจำ ใน Brain เรายังทบทวนความรู้ที่มีอยู่เมื่อเอกสารต้นทางเปลี่ยนแปลงและผู้ใช้ทำการแก้ไข ไม่ว่ากรณีใด สิ่งที่ทำให้ต้องเข้าไปจัดการคือตัวเนื้อหา

ให้การดึงข้อมูลส่งผลต่อการอัปเดตครั้งถัดไป

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

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

อย่างไรก็ตาม สิ่งเหล่านี้ไม่ปรากฏในเบนช์มาร์กด้านการเรียกคืนข้อมูลเลย วิธีที่จะรู้ว่าวงจรนี้ได้ผลหรือไม่ คือการให้เอเจนต์ทำงานที่ทำสำเร็จได้ด้วยหน่วยความจำเท่านั้น แล้วนับว่าทำสำเร็จบ่อยแค่ไหน โดยวัดต้นทุนและเวลาแฝงควบคู่ไปด้วย นั่นคือสิ่งที่ DolphinBench ทำ และเป็นเหตุผลที่คะแนนสูงสุดยังอยู่ในระดับเจ็ดสิบกว่า

วิธีสร้างเอเจนต์ที่มีหน่วยความจำแบบถาวรด้วย Perplexity

Agent API ของ Perplexity ไม่ได้มาพร้อมระบบหน่วยความจำที่ดูแลตัวเองได้อย่าง Brain เราขอบอกไว้ตั้งแต่แรก แต่สิ่งที่ API นี้มอบให้คุณคือส่วนประกอบของหน่วยความจำที่คุณต้องการ ได้แก่ ที่สำหรับเก็บขั้นตอนการทำงาน วิธีส่งต่อบริบทระหว่างรอบการสนทนา และเครื่องมือสำหรับอ่านและเขียนข้อมูลในคลังที่คุณควบคุมเอง

เริ่มต้นด้วยหน่วยความจำเชิงกระบวนการ

Skill แบบกำหนดเองจะรวบรวมคำสั่ง ขั้นตอน และไฟล์ประกอบไว้ภายใต้หมายเลขเวอร์ชัน ทีมแพลตฟอร์มสามารถเขียนการตรวจสอบการดีพลอย เกณฑ์การย้อนกลับ (rollback) และรูปแบบการรายงานเพียงครั้งเดียว จากนั้นให้แอปพลิเคชันต่าง ๆ อ้างอิง Skill เดียวกัน เมื่อขั้นตอนเปลี่ยนแปลง ทีมก็เพียงอัปโหลดเวอร์ชันใหม่

ขยาย

ที่มา: X

โปรไฟล์ก้าวไปอีกขั้น โดยโปรไฟล์จะบันทึกโมเดล คำสั่ง เครื่องมือ Skill ตัวเชื่อมต่อ และการตั้งค่าการรันของเอเจนต์ไว้ภายใต้ ID เดียวที่มีการกำหนดเวอร์ชัน

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

ทำไมสิ่งนี้จึงนับเป็นหน่วยความจำ? ลองย้อนกลับไปที่ห้องครัวที่มีคนอุ่นปลาในไมโครเวฟอีกครั้ง ใครก็ตามที่มาถึงเป็นคนถัดไปสามารถทำตามป้าย NO FISH ได้โดยไม่จำเป็นต้องเคยเห็นเหตุการณ์ที่มีคนร้องเรียน

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

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

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

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

ส่งต่อหน่วยความจำขณะทำงานระหว่างรอบการสนทนา

เอเจนต์รันการตรวจสอบการดีพลอย คุณถามว่า ‘ทำไมอันนั้นถึงล้มเหลว?’ ซึ่งเป็นคำถามต่อเนื่องที่สมเหตุสมผล ตราบใดที่เอเจนต์ยังมองเห็นได้ว่า “อันนั้น” หมายถึงอะไร

Agent API ของเรารองรับการส่งต่อบริบทการสนทนาได้สองวิธี:

• ส่งประวัติการสนทนาซ้ำด้วยตัวเอง: ใส่ข้อความก่อนหน้าไว้ในอาร์เรย์ input ของคำขอถัดไป คุณเป็นผู้ตัดสินใจว่าจะเก็บ สรุป ปกปิด หรือตัดสิ่งใดออกก่อนส่ง
• ดำเนินการต่อจากการตอบกลับที่เสร็จสมบูรณ์: บันทึก ID ของการตอบกลับนั้น แล้วส่งเป็น previous_response_id ไปพร้อมกับข้อความถัดไป เราจะเก็บสถานะการสนทนาไว้ฝั่งเซิร์ฟเวอร์ แอปพลิเคชันของคุณจึงไม่ต้องส่งรอบการสนทนาก่อนหน้าซ้ำ คุณสามารถดำเนินการต่อจากการตอบกลับล่าสุดในลำดับได้

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

ใช้ที่เก็บหน่วยความจำเชิงเหตุการณ์และเชิงความหมายของคุณเอง

นี่คือส่วนที่ Agent API ปล่อยให้คุณจัดการเอง

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

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

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

ตัวเชื่อมต่อของเราช่วยให้เอเจนต์เข้าถึงหลักฐานที่อยู่เบื้องหลังสิ่งที่จดจำไว้ GitHub, Slack, Google Drive, Datadog, Linear และ Notion อยู่ในแคตตาล็อกที่มีการจัดการของเรา และคุณสามารถเพิ่มตัวเชื่อมต่อแบบกำหนดเองสำหรับระบบภายในได้

สุดท้าย ให้กำหนดว่าจะทบทวนประวัติเมื่อใด และจะปรับปรุงข้อมูลฉบับปัจจุบันเมื่อใด

ทดสอบว่าอะไรยังคงอยู่เมื่อเริ่มเซสชันใหม่

ตอนนี้ให้ปิดการสนทนา เริ่มคำขอใหม่โดยไม่ส่งข้อความเก่าซ้ำหรือส่ง previous_response_id แต่ให้เอเจนต์เข้าถึงที่เก็บหน่วยความจำเดิม แล้วขอให้เอเจนต์ทำงานที่เกี่ยวข้องโดยไม่ต้องบอกการแก้ไขซ้ำ

หากยังต้องเตือนอยู่ แสดงว่าคุณยังทำไม่เสร็จ

สำหรับเอเจนต์ที่ทำหน้าที่ดีพลอย ให้สร้างการทดสอบสองสามรายการเกี่ยวกับสิ่งที่ควรส่งต่อไป:

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

คู่มือการทดสอบรีเกรสชันของเราแสดงวิธีบันทึกผลลัพธ์ของเอเจนต์และหลักฐานที่ดึงมา ตรวจสอบเทียบกับพฤติกรรมที่คาดหวัง และเปรียบเทียบการรันหลังจากเปลี่ยนคำสั่งหรือโมเดล

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

เมื่อมีสิ่งใดล้มเหลว ให้บันทึกกรณีนั้นไว้ การเปลี่ยนแปลงครั้งถัดไปต้องผ่านกรณีนี้ให้ได้

หรือข้ามการสร้างไปเลย: Brain ใน Computer

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

คุณไม่จำเป็นต้องสร้างลูปนั้นเอง เพียงแค่ทำงานของคุณไปตามปกติ

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

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

ขยาย

ตัวอย่างเช่น ที่ Rho การตัดสินใจของโปรเจกต์ด้านการออกใบแจ้งหนี้กระจัดกระจายอยู่ใน Slack, Notion, Jira, Figma และ Google Docs ทีมจึงตั้งค่า Computer ให้ตรวจสอบการเปลี่ยนแปลงในช่วงกลางคืน แจ้งเตือนความไม่สอดคล้องกัน และเผยแพร่สรุปประจำเช้าใน Slack

Oktawian Jurkiewicz วิศวกรซอฟต์แวร์ของทีม สังเกตเห็นว่า Computer ยังสร้างหน่วยความจำสำหรับโปรเจกต์นี้ด้วย “เราไม่ได้กำหนดไว้” เขากล่าว “Computer หาคำตอบเองว่าควรจัดเก็บข้อมูลส่วนใดจากแต่ละแหล่ง”

ทีมรายงานว่าลดเวลาประชุมประจำสัปดาห์จาก 2.5 ชั่วโมงเหลือ 15 นาที และประเมินว่าช่วยประหยัดเวลาทำงานได้ 120 ชั่วโมงตลอดโปรเจกต์ 12 สัปดาห์

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

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

คำถามที่พบบ่อยเกี่ยวกับหน่วยความจำของเอเจนต์ AI

เอเจนต์ AI มีหน่วยความจำได้หรือไม่?

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

ตัวอย่างเช่น Brain ใน Perplexity Computer สร้างบริบทการทำงานจากเซสชัน เครื่องมือที่เชื่อมต่อ ไฟล์ และการแก้ไขของผู้ใช้

เอเจนต์ AI ใช้ RAM เท่าใด?

ไม่มีข้อกำหนดตายตัว หากเอเจนต์ของคุณเรียกใช้โมเดลที่โฮสต์ไว้ผ่าน Perplexity Agent API คุณก็ไม่จำเป็นต้องโหลดโมเดลนั้นลงใน RAM ของคุณเอง แต่แอปพลิเคชันและเครื่องมือภายในเครื่องของคุณยังคงต้องใช้หน่วยความจำ

การรันโมเดลภายในเครื่องนั้นแตกต่างออกไป ที่ 4 บิตต่อพารามิเตอร์ พารามิเตอร์แปดพันล้านตัวจะคิดเป็นข้อมูลน้ำหนักดิบประมาณ 4 GB หน่วยความจำที่ต้องใช้จริงจะสูงกว่านี้เมื่อรวมโอเวอร์เฮดของการควอนไทซ์ การประมวลผลบริบท และซอฟต์แวร์ที่ใช้รันโมเดล

หน่วยความจำแบบใดดีที่สุดสำหรับเอเจนต์ AI?

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

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