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

> วิธีเปิดใช้ memory บันทึกถูกเก็บไว้ที่ใด และ /flush, /remember, /dream และ /memory ทำงานอย่างไร ลำดับความสำคัญของการตั้งค่า การตรวจสอบ และการลบรายการ

Source: https://ailoot.ai/blog/th/grok-build-memory/
Canonical: https://ailoot.ai/blog/th/grok-build-memory/
Language: th
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-111
Revision: sha256-aa46040be6ecfdf5c319080ff1df46f0b0f5af655c1a5ea345056e69ce42dd75


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

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

[ดูข้อมูลเชิงปฏิบัติเกี่ยวกับการใช้ Ailoot ได้ในเอกสารประกอบ](https://ailoot.ai/docs/)

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

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

ประเด็นสำคัญของส่วนนี้

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

</div>

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

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

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

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

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

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

ประเด็นสำคัญของส่วนนี้

หากต้องการเปิดใช้สำหรับการเรียกใช้งานครั้งเดียว ให้ตั้งค่าตัวแปรสภาพแวดล้อม `GROK_MEMORY=1` หากต้องการเปิดใช้ต่อเนื่อง ให้เพิ่มส่วน `[memory]` ที่มี `enabled = true` ลงใน `~/.grok/config.toml` หากต้องการให้เพิ่มบันทึกที่จัดเก็บไว้เมื่อเริ่มทำงาน ให้เริ่มเซสชันใหม่ด้วย `/new` หลังเปิดใช้ memory

</div>

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

```bash
GROK_MEMORY=1 grok
```

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

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

```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 บันทึกอะไรไว้ และเก็บไว้ที่ไหน?

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

ประเด็นสำคัญของส่วนนี้

บันทึกจัดเก็บไว้ใน `~/.grok/memory/` เป็นไฟล์ Markdown ได้แก่ `MEMORY.md` ส่วนกลางสำหรับทุกโปรเจกต์, `MEMORY.md` แยกสำหรับแต่ละโปรเจกต์ และบันทึกเซสชัน สรุปอัตโนมัติเมื่อจบเซสชันจะเขียนโดยไม่เรียกใช้โมเดล ส่วนบันทึกโดยละเอียดสร้างด้วย `/flush` และ `/remember` ขณะที่ `/dream` จะจัดกลุ่มรายการที่กระจัดกระจายตามหัวข้อ

</div>

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

| ตำแหน่ง | ขอบเขต | เนื้อหา |
|----|----|----|
| `~/.grok/memory/MEMORY.md` | ส่วนกลาง | ข้อเท็จจริงและการตั้งค่าสำหรับทุกโปรเจกต์ของคุณ |
| `~/.grok/memory/` + ไดเรกทอรีโปรเจกต์ที่มีแฮช + `/MEMORY.md` | โปรเจกต์ | แนวทางปฏิบัติและบริบทสำหรับรีโพซิทอรีเฉพาะ |
| `~/.grok/memory/` + ไดเรกทอรีโปรเจกต์ที่มีแฮช + `/sessions/` | เซสชัน | สรุปและบันทึกของแต่ละเซสชัน |

ชื่อไดเรกทอรีโปรเจกต์จะเพิ่มแฮชแบบสั้นของตัวระบุรีโพซิทอรีเข้าไป ใช้รีโมต `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 ถูกเพิ่มเข้าไปในเซสชันใหม่อย่างไร?

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

ประเด็นสำคัญของส่วนนี้

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

</div>

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

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

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

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

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

ประเด็นสำคัญของส่วนนี้

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

</div>

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

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

| ปุ่ม | การทำงาน |
|----|----|
| `↑`/`↓` หรือ `j`/`k` | เลื่อนดูรายการ |
| `/` | กรองรายการ |
| `y` | คัดลอกพาธของไฟล์ที่เลือก |
| `x` | ลบบันทึกที่เลือก (กดอีกครั้งเพื่อยืนยัน) |
| `t` | เปิดหรือปิด memory |
| `Esc` | ปิดหน้าต่าง |

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

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

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

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

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

ประเด็นสำคัญของส่วนนี้

คุณเขียนไฟล์คำแนะนำ เช่น CLAUDE.md หรือ AGENTS.md แล้ววางไว้ในรีโพซิทอรี เพื่อให้ทีมใช้ร่วมกันผ่าน Git ส่วนเอเจนต์ Grok Build ดูแลบันทึก memory และจัดเก็บไว้ใน `~/.grok/memory/` ซึ่งอยู่นอกรีโพซิทอรี บันทึกเหล่านี้เป็นข้อมูลส่วนบุคคลและไม่ได้แชร์ผ่าน Git

</div>

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

Memory ไม่ได้ใช้แทนไฟล์คำแนะนำ กฎทั่วไปของโปรเจกต์ที่จำเป็นสำหรับทั้งทีมและเอเจนต์ยังควรอยู่ในรีโพซิทอรี เรามีคู่มือแยกสำหรับการใช้ไฟล์คำแนะนำไฟล์เดียวร่วมกับ Claude Code, Codex และ Cursor: [ใช้ AGENTS.md และ CLAUDE.md ร่วมกัน](https://ailoot.ai/blog/th/agents-md-claude-md-one-instruction-file/) ส่วน memory ใช้เก็บบริบทส่วนตัว เช่น การตั้งค่าของคุณ สิ่งที่เคยลองไปแล้ว และการตัดสินใจที่ได้ข้อสรุปแล้ว

Claude ใช้การแบ่งแยกในลักษณะคล้ายกัน โดยอธิบายความแตกต่างระหว่าง memory กับ CLAUDE.md ไว้ในบทความ [Memory ของ Claude และ CLAUDE.md](https://ailoot.ai/blog/th/claude-memory-claude-md-auto-memory/) หากต้องการเปรียบเทียบตัวเครื่องมือเอง โปรดดู [Grok Build หรือ Claude Code](https://ailoot.ai/blog/th/grok-build-vs-claude-code/)

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

<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Section takeaway">

ประเด็นสำคัญของส่วนนี้

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

</div>

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

- **สถานะทดลอง** คำสั่ง เกณฑ์ และพฤติกรรมอาจเปลี่ยนในเวอร์ชันต่อไป หากมีสิ่งใดไม่ทำงานตามที่คาดไว้ ให้ตรวจดูคู่มือ 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` หรือแก้ไขไฟล์โดยตรง ฟีเจอร์นี้ยังอยู่ในขั้นทดลอง จึงควรตรวจสอบเกณฑ์และคำสั่งในคู่มืออย่างเป็นทางการ และทบทวนบันทึกเป็นระยะ

<div class="section" role="doc-bibliography" aria-label="Sources">

### แหล่งที่มา

- Grok Build, คู่มือ “Cross-Session Memory” อย่างเป็นทางการ (คู่มือผู้ใช้ บทที่ 13): <https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/13-memory.md>
- Grok Build, รีโพซิทอรีของ xAI บน GitHub: <https://github.com/xai-org/grok-build>

</div>





[ไปที่ Ailoot](https://ailoot.ai/)

## คำถามที่พบบ่อย

### ทำไมเปิด memory แล้วบันทึกไม่ปรากฏ?

บันทึกถูกเพิ่มในรอบแรกของเซสชันใหม่ ให้เริ่มใหม่หลังเปิด memory แล้วตรวจสถานะด้วย grok inspect กระบวนการที่เริ่มด้วย GROK_MEMORY=0 เปิดผ่านสวิตช์ในเซสชันไม่ได้

### ปิด memory แล้วไฟล์ถูกลบหรือไม่?

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


## Ailoot · บริษัทและพอร์ตโฟลิโอโครงการของบริษัท

Ailoot อาศัยประสบการณ์การดำเนินงานที่สั่งสม ฐานลูกค้าขนาดใหญ่ บริการที่เสถียร และการติดตาม KPI อย่างต่อเนื่อง

บริษัทและพอร์ตโฟลิโอโครงการของบริษัท: ลูกค้าหลายล้านราย; ยอดขายระดับหลายพันล้านต่อเดือน.

Ailoot นำประสบการณ์การดำเนินงานนี้มาใช้เพื่อให้เข้าถึงฟังก์ชัน AI ผ่าน API ในผลิตภัณฑ์ของลูกค้า เอเจนต์ แอปพลิเคชัน และระบบอัตโนมัติ