Memory ของ Grok Build ข้ามเซสชัน: การตั้งค่าและข้อจำกัด

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

คำอธิบายนี้อ้างอิงจากคู่มืออย่างเป็นทางการในรีโพซิทอรี xai-org/grok-build ณ วันที่ 20 กันยายน 2026 ผู้เขียนบทความต้นฉบับไม่ได้ทดลองใช้ผลิตภัณฑ์นี้ กลไกการทำงานอธิบายตามเอกสาร ไม่ใช่จากการทดสอบด้วยตนเอง

ดูข้อมูลเชิงปฏิบัติเกี่ยวกับการใช้ Ailoot ได้ในเอกสารประกอบ

Memory ใน Grok Build มีประโยชน์อย่างไร?#

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

เมื่อเปิดใช้ memory แล้ว Grok Build สามารถทำสิ่งต่อไปนี้ได้:

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

ฟีเจอร์นี้ยังอยู่ในขั้นทดลองและปิดอยู่โดยค่าเริ่มต้น จนกว่าคุณจะเปิดใช้ พฤติกรรมของเอเจนต์จะไม่เปลี่ยนแปลง

เปิดใช้ memory อย่างไร?#

ครั้งเดียว สำหรับการเรียกใช้ครั้งเดียว:

GROK_MEMORY=1 grok

ตัวแปรนี้มีผลเฉพาะกับการเรียกใช้ครั้งนี้ คำสั่ง export GROK_MEMORY=1 จะคงค่าไว้ในเชลล์ปัจจุบันและเปิดใช้ memory สำหรับการเรียกใช้ grok ครั้งต่อ ๆ ไปทั้งหมดจากเชลล์นั้น จนกว่าเซสชันเทอร์มินัลจะสิ้นสุดหรือคุณเรียกใช้ export GROK_MEMORY=0

เปิดใช้ถาวรผ่านการตั้งค่า เพิ่มข้อความนี้ลงใน ~/.grok/config.toml:

[memory]
enabled = true

ภายในเซสชันโดยไม่ต้องเริ่มใหม่: เปิด /memory แล้วกด t

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

หากมีการระบุการตั้งค่าไว้หลายแห่ง ลำดับความสำคัญจะเป็นดังนี้:

• GROK_MEMORY=0 จะปิด memory อย่างบังคับสำหรับทั้งโปรเซสและมีลำดับความสำคัญสูงสุด
• หากตั้งค่า enabled = false ไว้อย่างชัดเจนในไฟล์การตั้งค่า จะปิด memory แม้ว่าการตั้งค่าระยะไกลที่จัดการไว้จะเปิดใช้ก็ตาม
• เปิดใช้ memory ได้ด้วย GROK_MEMORY=1, enabled = true ในไฟล์การตั้งค่า หรือการตั้งค่าระยะไกลที่จัดการไว้
• หากไม่ได้ระบุอะไรไว้ memory จะปิดอยู่

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

Grok Build บันทึกอะไรไว้ และเก็บไว้ที่ไหน?#

โครงสร้างไดเรกทอรี ~/.grok/memory/:

ชื่อไดเรกทอรีโปรเจกต์จะเพิ่มแฮชแบบสั้นของตัวระบุรีโพซิทอรีเข้าไป ใช้รีโมต origin ในรูปแบบ “organization/repository” เพื่อระบุโปรเจกต์ หรือใช้พาธไดเรกทอรีหากไม่มีรีโพซิทอรี Git ดังนั้น โคลนและ worktree (สำเนาทำงานแยกของสาขา Git) จากรีโพซิทอรีเดียวกันจึงใช้ memory ของโปรเจกต์ร่วมกัน สิ่งที่เอเจนต์จดจำไว้ในสำเนาหนึ่งจะใช้ได้ในอีกสำเนาด้วย

รายการต่าง ๆ ถูกสร้างขึ้นได้สี่วิธี:

1. สรุปอัตโนมัติเมื่อจบเซสชัน เมื่อเซสชันสิ้นสุด Grok Build จะบันทึกสรุประบบสั้น ๆ ลงในบันทึกรายวัน ได้แก่ จำนวนข้อความ การโต้ตอบที่มีสาระสำคัญช่วงแรกไม่เกินห้ารายการ และวันที่กับเวลา สรุปนี้สร้างจากข้อมูลเมตาโดยไม่เรียกใช้โมเดลและไม่ทำให้เกิดความล่าช้า เซสชันที่สั้นมากจะถูกข้ามไป หากมีการโต้ตอบที่มีสาระสำคัญน้อยกว่าสามครั้ง หรือข้อความของคุณมีขนาดน้อยกว่า 50 ไบต์ จะไม่มีการสร้างรายการ สรุปนี้ไม่มีข้อมูลเกี่ยวกับเครื่องมือที่ใช้ พาธไฟล์ หรือคำสั่ง ปิดสรุปอัตโนมัติได้ด้วยการตั้งค่า session.save_on_end = false
2. /flush—บันทึกโดยละเอียดตามคำขอ เมื่อใช้คำสั่งนี้ โมเดลจะสรุปประเด็นสำคัญที่สุดจากเซสชันปัจจุบัน ได้แก่ การตัดสินใจ รูปแบบ ขั้นตอนแก้ไขข้อบกพร่อง และข้อค้นพบเกี่ยวกับ API จากนั้นจะเขียนสรุปลงในบันทึกที่มีวันที่กำกับและทำดัชนีไว้สำหรับเซสชันในอนาคต เอกสารแนะนำให้เรียกใช้ /flush ก่อนย่อบริบท เมื่อจบเซสชันแก้ไขข้อบกพร่องที่สำเร็จ และหลังค้นพบรูปแบบสำคัญ
3. /remember—คำขอให้จดจำบางสิ่งอย่างชัดเจน พิมพ์ /remember always open PR links after sending หรือบอกเอเจนต์ว่า “จำไว้ว่า...” ก่อนเขียนรายการ จะมีแผงตรวจทานปรากฏขึ้น บันทึกจะถูกจัดเก็บหลังจากคุณยืนยันเท่านั้น และข้อความ Memory saved to ~/.grok/memory/MEMORY.md จะปรากฏในฟีด ข้อมูลโปรเจกต์จะถูกเก็บไว้ใน MEMORY.md ของโปรเจกต์ ส่วนข้อมูลที่ใช้ร่วมกันในทุกโปรเจกต์จะอยู่ในไฟล์ส่วนกลาง
4. /dream—การรวมข้อมูล คำสั่งนี้จัดกลุ่มบันทึกและโน้ตที่กระจัดกระจายตามหัวข้อ แล้วลบรายการซ้ำเพื่อให้ค้นหาได้แม่นยำขึ้น เช่นเดียวกับ /flush การรวมข้อมูลทำโดยโมเดล ซึ่งอ่านรายการที่สะสมไว้แล้วเขียนใหม่เป็นหัวข้อต่าง ๆ ดังนั้นควรตรวจทานผลลัพธ์ด้วย /memory เป็นระยะ นอกจากนี้ยังมีโหมดอัตโนมัติ โดยค่าเริ่มต้น Grok Build จะตรวจสอบเงื่อนไขเมื่อเริ่มทำงานและทุกชั่วโมง แล้วเริ่มรวมข้อมูลเมื่อผ่านไปอย่างน้อย 24 ชั่วโมงและมีเซสชันสะสมอย่างน้อย 5 เซสชัน ตั้งค่าเกณฑ์ได้ในส่วน [memory.dream] ของไฟล์การตั้งค่า

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

Memory ถูกเพิ่มเข้าไปในเซสชันใหม่อย่างไร?#

การแทรกข้อมูลครั้งแรกใช้เกณฑ์การเลือก min_score = 0.9 ซึ่งเปลี่ยนได้ในส่วน [memory.initial_injection] หลังจากย่อบริบทโดยอัตโนมัติ เอเจนต์จะค้นหา memory อีกครั้งเพื่อกู้คืนข้อมูลที่อาจถูกนำออกจากบริบทพร้อมกับการโต้ตอบเก่า ๆ

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

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

ดู แก้ไข และลบบันทึกอย่างไร?#

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

ปุ่มที่ใช้ได้ในภาพรวม:

หน้าต่างนี้ลบบันทึกและไฟล์เซสชันแต่ละรายการได้ แต่ลบดัชนี MEMORY.md ที่สร้างขึ้น (ทั้งส่วนกลางและของโปรเจกต์) ไม่ได้

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

คำขอ “ลืมเรื่อง snake_case” ใช้งานได้แต่ไม่มีการรับประกัน โมเดลจะค้นหาและลบรายการที่ตรงกัน แต่อาจพลาดบางรายการ หากต้องการให้แน่ใจว่าลบแล้ว ให้เปิดไฟล์ (คัดลอกพาธได้สะดวกด้วย y ใน /memory) แล้วลบรายการด้วยตนเอง ล้าง memory ทั้งหมดจากบรรทัดคำสั่งได้ด้วย grok memory clear สำหรับ memory ของโปรเจกต์, grok memory clear --global สำหรับ memory ส่วนกลาง และ grok memory clear --all สำหรับทั้งสองส่วน

Memory แตกต่างจากไฟล์คำแนะนำของรีโพซิทอรีอย่างไร?#

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

Memory ไม่ได้ใช้แทนไฟล์คำแนะนำ กฎทั่วไปของโปรเจกต์ที่จำเป็นสำหรับทั้งทีมและเอเจนต์ยังควรอยู่ในรีโพซิทอรี เรามีคู่มือแยกสำหรับการใช้ไฟล์คำแนะนำไฟล์เดียวร่วมกับ Claude Code, Codex และ Cursor: ใช้ AGENTS.md และ CLAUDE.md ร่วมกัน ส่วน memory ใช้เก็บบริบทส่วนตัว เช่น การตั้งค่าของคุณ สิ่งที่เคยลองไปแล้ว และการตัดสินใจที่ได้ข้อสรุปแล้ว

Claude ใช้การแบ่งแยกในลักษณะคล้ายกัน โดยอธิบายความแตกต่างระหว่าง memory กับ CLAUDE.md ไว้ในบทความ Memory ของ Claude และ CLAUDE.md หากต้องการเปรียบเทียบตัวเครื่องมือเอง โปรดดู Grok Build หรือ Claude Code

ข้อจำกัดและวิธีตรวจสอบว่า memory ทำงาน#

โปรดคำนึงถึงข้อจำกัดต่อไปนี้:

• สถานะทดลอง คำสั่ง เกณฑ์ และพฤติกรรมอาจเปลี่ยนในเวอร์ชันต่อไป หากมีสิ่งใดไม่ทำงานตามที่คาดไว้ ให้ตรวจดูคู่มือ memory ของรีโพซิทอรี
• การแทรกข้อมูลครั้งแรกในเซสชันใหม่ หลังเปิดใช้ memory ให้เริ่มทำงานด้วย /new เพื่อให้เพิ่มบันทึกที่จัดเก็บไว้ในเทิร์นแรก
• โมเดลเป็นผู้ตัดสินใจว่าอะไรสำคัญ โมเดลสร้างสรุป /flush และเลือกว่าจะใส่อะไรลงในบันทึก ทุกหนึ่งหรือสองสัปดาห์ ให้เปิด /memory แล้วตรวจดูสิ่งที่สะสมไว้ ลบทุกอย่างที่ไม่จำเป็น
• อย่าขอให้เอเจนต์จดจำข้อมูลลับ คีย์ โทเค็น และรหัสผ่านไม่ควรอยู่ในบันทึกระยะยาว เพราะไฟล์ใน ~/.grok/memory/ จัดเก็บเป็นข้อความธรรมดา หากมีการบันทึกข้อมูลละเอียดอ่อนไว้ ให้ลบออกโดยแก้ไขไฟล์
• Memory ของโปรเจกต์ใช้ร่วมกันระหว่างสำเนาของรีโพซิทอรี หากเอเจนต์จดจำบางสิ่งไว้ในโคลนหนึ่ง แต่ข้อมูลนั้นไม่เป็นปัจจุบันสำหรับอีกโคลน ให้คำนึงถึงไดเรกทอรีที่ใช้ร่วมกันขณะล้างข้อมูล

หาก memory ไม่ทำงาน:

1. ตรวจสอบผลลัพธ์ของ grok inspect เพื่อยืนยันว่าเปิดใช้ memory อยู่
2. ตรวจสอบว่า GROK_MEMORY=0 หรือไฟล์การตั้งค่าไม่ได้ปิดใช้งาน memory
3. สำหรับการวินิจฉัย ให้เรียกใช้ RUST_LOG=debug GROK_LOG_FILE=/tmp/grok.log grok แล้วตรวจสอบบรรทัดที่เกี่ยวกับ memory ใน /tmp/grok.log

สรุปโดยย่อ#

เปิดใช้ memory ของ Grok Build ได้ด้วย GROK_MEMORY=1 หรือ [memory] enabled = true ใน ~/.grok/config.toml หากต้องการให้เพิ่มบันทึกในครั้งแรกหลังเปิดใช้ ให้เริ่มเซสชันใหม่ด้วย /new เอเจนต์เขียนบันทึกไว้ใน ~/.grok/memory/ ได้แก่ สรุปเซสชันที่ไม่เรียกใช้โมเดล สรุปโดยละเอียดด้วย /flush รายการที่ระบุชัดเจนด้วย /remember หลังจากคุณยืนยัน และหัวข้อที่จัดระเบียบแล้วด้วย /dream ดูและจัดการบันทึกผ่าน /memory หรือแก้ไขไฟล์โดยตรง ฟีเจอร์นี้ยังอยู่ในขั้นทดลอง จึงควรตรวจสอบเกณฑ์และคำสั่งในคู่มืออย่างเป็นทางการ และทบทวนบันทึกเป็นระยะ

ไปที่ Ailoot