📘 תיעוד 37

זיכרון חוצה הפעלות

הזיכרון מאפשר ל-Grok להיזכר בעובדות, החלטות ודפוסים מהפעלות קודמות. Grok ממפתח את המידע שאתה שומר ומחפש בו באופן אוטומטי, כך שהפעלה חדשה יכולה לעשות שימוש חוזר בהקשר רלוונטי.

#מה זה זיכרון?

ללא זיכרון, כל הפעלה של Grok מתחילה מחדש: המודל אינו יודע דבר על הפעלות קודמות. כאשר אתה מפעיל את הזיכרון, Grok יכול:

• להיזכר במוסכמות פרויקט שהסברת בעבר.
• לעשות שימוש חוזר בשלבי ניפוי שגיאות שעבדו.
• להעביר החלטות ארכיטקטוניות הלאה בין הפעלות.
• להימנע משאלות חוזרות על דברים שכבר יש לו תשובות עליהם.

הזיכרון הוא ניסיוני ומנוטרל כברירת מחדל.

#כיצד הזיכרון מאורגן

לזיכרון יש שני תחומי הגדרה (scopes). זיכרון גלובלי מכיל עובדות שתקפות בכל הפרויקטים שלך, וזיכרון סביבת עבודה מכיל עובדות על מאגר קוד יחיד. שכפולים (clones) ועצי עבודה (worktrees) של אותו מאגר חולקים תחום הגדרה אחד של סביבת עבודה.

כל תחום הגדרה שומר את הידע שלו כקובצי Markdown רגילים. התיקייה topics/ מכילה הערות ערוכות, קובץ אחד לכל נושא, וזה מה ש-Grok קורא בתחילת הפעלה. עובדות חדשות שנלכדו מתור שהושלם נשמרות כתצפיות קטנות, שסבב איחוד מאוחר יותר (/dream) ממזג לתוך נושאים. אינדקס מוגבל שנוצר משני תחומי ההגדרה מוזרק להקשר של המודל פעם אחת בכל הפעלה, כדי שהוא יוכל להחליט אילו נושאים לפתוח.

הערות שתיעדת עם גרסאות קודמות של Grok Build מועברות אוטומטית בפעם הראשונה שסביבת עבודה נפתחת לאחר עדכון: כל סעיף בהערות הקודמות הופך לנושא, וסעיפים ששמם כבר תואם לנושא מתווספים אליו תחת הכותרת "From earlier sessions". הקבצים הקודמים נשארים במקומם ללא שינוי.

הקש על s בחלון של /memory לקבלת אבחון מקומי ללא תוכן: סמני לכידה (capture cursors), ספירת תורים, גיל הפריטים הממתינים, מצב החכירה של האיחוד (consolidation lease state), תוצאות אחרונות וספירת ארכיונים. הקש שם על y כדי להעתיק אותם.

טלמטריית המוצר של הזיכרון כוללת רק ערכי enum קבועים, ערכים בוליאניים, מונים ומשכי זמן. היא לעולם אינה כוללת פרומפטים, הצהרות, שמות נושאים, מילות מפתח, נתיבים, פלט מודל או שגיאות בטקסט חופשי.

#הפעלת זיכרון

#הגדרה בקובץ תצורה (קבוע)

# ~/.grok/config.toml
[memory]
enabled = true

#משתנה סביבה

export GROK_MEMORY=1
grok

#השבתה כפויה

כדי להשבית את הזיכרון עבור התהליך גם כאשר קובץ TOML או הגדרות מרוחקות מפעילים אותו:

export GROK_MEMORY=0

#החלפה במהלך הפעלה

הפעל או כבה את הזיכרון במהלך הפעלה ללא הפעלה מחדש: פתח את /memory והקש על t.

ההחלפה תקפה להפעלה הנוכחית בלבד, היא אינה נשמרת ב-config.toml. כיבוי מסיר את הגישה לכלי הזיכרון אך שומר את הקבצים הקיימים בדיסק. הפעלה מחדש מאתחלת מחדש את אחסון הזיכרון ורושמת את כלי הזיכרון.

#סדר עדיפויות

1. השבתה כפויה ברמת התהליך (דגל תאימות --no-memory או GROK_MEMORY=0) מכבה את הזיכרון.
2. הגדרה מפורשת של [memory] enabled = false ב-TOML הקובע מכבה את הזיכרון, כולל כל מה שהופעל על ידי הגדרות מרוחקות מנוהלות.
3. אחרת, הזיכרון מופעל על ידי GROK_MEMORY=1, [memory] enabled = true, או הגדרה מרוחקת מנוהלת.

בקרות הפצה מדורגת (staged-rollout) ומתג השבתה (kill-switch) עבור מפעילים מתועדות בהערות ההקשחה הפנימיות, ולא כאן.

#כיצד הזיכרון מאוחסן

הזיכרון מאוחסן כקובצי Markdown תחת ~/.grok/memory/:

Grok מוסיף לסוף ספריית סביבת העבודה גיבוב (hash) קצר של זהות מאגר הקוד. הזהות היא ה-remote של origin במבנה org/repo כאשר הספרייה היא מאגר Git עם remote של origin, או נתיב הספרייה במקרים אחרים. מכיוון ששכפולים (clones) ועצי עבודה (worktrees) של אותו מאגר חולקים את אותו remote של origin, הם חולקים גם את אותה ספריית זיכרון.

אינדקס SQLite תומך בחיפוש בכל קובצי הזיכרון:

• FTS5 מספק את חיפוש הטקסט המלא כברירת מחדל לצורך התאמת מילות מפתח.
• vec0 מוסיף חיפוש וקטורי לדמיון סמנטי כאשר מוגדר מודל embedding.

#שמירות אוטומטיות

כאשר הפעלה מסתיימת, Grok שומר סיכום מטא-דאטה מובנה ביומן היומי של אותה הפעלה. הסיכום מכיל:

• ספירת הודעות (משתמש, עוזר ותוצאות כלים).
• נושאים: הפרומפטים המהותיים הראשונים של המשתמש מההפעלה, עד חמישה.
• תאריך ושעת ההפעלה (UTC).

Grok בונה את הסיכום מתוך מטא-דאטה של השיחה ללא קריאת LLM, ללא תוספת זמני תגובה. Grok מדלג על השמירה עבור הפעלות זניחות: כאלה שיש בהן פחות משלושה פרומפטים מהותיים, או פחות מ-50 בתים של טקסט משתמש.

הסיכום אינו מתעד שימוש בכלים, נתיבי קבצים או פקודות מעטפת. מזהה ההפעלה מהווה חלק משם קובץ היומן. כדי לכבות שמירות אוטומטיות, הגדר session.save_on_end = false. ללכידה עשירה יותר של החלטות, דפוסים ושיקולים, השתמש ב-/flush.

#שמירת ידע עשיר באמצעות /flush

ללכידה עשירה יותר של החלטות, דפוסים, תהליכי ניפוי שגיאות ותגליות API, השתמש ב-/flush ב-TUI:

/flush

פקודה זו מפעילה סיכום מבוסס LLM של התוכן החשוב ביותר בהפעלה הנוכחית וכותבת אותו לקובץ יומן הפעלה מתוארך. הסיכום ממופתח וניתן לחיפוש בהפעלות עתידיות.

השתמש ב-/flush כאשר ברצונך לשמר הקשר חשוב:

• לפני דחיסה (compaction, אשר משליכה תורי שיחה ישנים)
• בסיומה של הפעלת ניפוי שגיאות פורייה
• לאחר גילוי דפוסים או מוסכמות חשובים

#עבודה עם הזיכרון

#זכור (Remember)

בקש מ-Grok לזכור משהו, והוא יוסיף את ההערה לקובץ MEMORY.md: קובץ סביבת העבודה עבור פריטים ספציפיים לפרויקט, או הקובץ הגלובלי ~/.grok/memory/MEMORY.md עבור העדפות חוצות פרויקטים:

> remember to always open PR links after pushing

Grok מתעד רשומות כהצהרות קבועות תחת כותרות מאורגנות, כגון `

#Preferences,

#Project Context, או

#Debugging`. מנגנון המעקב אחר קבצים ממפתח מחדש את השינוי בחיפוש הזיכרון הבא, כך שהרשומה החדשה ניתנת לחיפוש כבר בתוך ההפעלה הנוכחית.

באפשרותך גם לשמור הערה ישירות באמצעות הפקודה /remember:

/remember always open PR links after pushing

הפעלת /remember ללא טקסט מכניסה אותך למצב זכירה, שבו השורה הבאה שתקליד תהפוך להערה. בכל אחת מהדרכים, Grok פותח חלונית בדיקה המציגה את ההערה (כולל גרסה מנוסחת מחדש לבחירה שתוכל לעבור אליה באמצעות Tab). ההערה נכתבת רק לאחר שתאשר. בעת שמירה, Grok מציג Memory saved to ~/.grok/memory/MEMORY.md.

#שכח (Forget)

בקש מ-Grok לשכוח משהו, והוא יאתר ויסיר את הרשומה התואמת:

> forget the snake_case convention

שכחה פועלת לפי עיקרון של מאמץ מרבי (best-effort): המודל מחפש בזיכרון ומסיר רשומות תואמות. להסרה מובטחת, ערוך את הקבצים תחת ~/.grok/memory/ ישירות ומחק את הרשומה בעצמך. כדי לאתר קובץ, פתח את סייר /memory והקש על y כדי להעתיק את הנתיב שלו.

#היזכרות (Recall)

שאל מה Grok זוכר:

> what do you remember?

Grok מחפש בכל קובצי הזיכרון ומסכם את מה שהוא יודע, מקובץ לפי מקור: העדפות גלובליות, ידע ספציפי לפרויקט והיסטוריית הפעלות. השתמש ב-/memory כדי לעיין בקבצים הגולמיים.

#עריכה ישירה

באפשרותך לערוך קובצי זיכרון ישירות תחת ~/.grok/memory/. מנגנון המעקב אחר קבצים ממפתח מחדש את השינויים שלך בחיפוש הזיכרון הבא. השתמש ב-/flush כדי לשמור את ההפעלה הנוכחית כעת, וב-/dream כדי לאחד יומני הפעלות לנושאים מאורגנים.

#עיון בזיכרון באמצעות /memory

הפקודה /memory פותחת חלון מודאלי המציג את כל קובצי הזיכרון:

/memory

הקבצים מקובצים לפי תחום הגדרה:

• Global: זיכרון חוצה פרויקטים (MEMORY.md).
• Workspace: זיכרון ספציפי לפרויקט (MEMORY.md).
• Sessions: סיכומים לכל הפעלה, בסדר כרונולוגי הפוך.

החלון המודאלי משתמש בפריסת חלונית מפוצלת: רשימת הקבצים משמאל, ותצוגה מקדימה לקריאה בלבד מימין. התצוגה המקדימה מתעדכנת תוך כדי מעבר ברשימה.

#מקשי קיצור

חלונית התצוגה המקדימה מיועדת לקריאה בלבד. ניתן לגלול בה באמצעות גלגלת העכבר או על ידי גרירת פס הגלילה. באפשרותך למחוק קובצי הפעלה בלבד, ולא את MEMORY.md הגלובלי או של סביבת העבודה.

כאשר אזור התוכן של חלון הזיכרון קטן מ-80 עמודות, החלון מסתיר את חלונית התצוגה המקדימה ומציג את רשימת הקבצים בלבד.

ניתן גם לפתוח את /memory מלוח הפקודות.

#התראות זיכרון

כאשר אתה שומר הערה באמצעות /remember, Grok מאשר זאת באזור הגלילה לאחור (scrollback):

Memory saved to ~/.grok/memory/MEMORY.md

שמירות ברקע: שטיפה אוטומטית (flush), איחוד Dream אוטומטי וסיום הפעלה, מתבצעות בשקט ואינן מציגות הודעה באזור הגלילה לאחור. הפקודות /flush ו-/dream מדווחות על תוצאתן באזור הגלילה לאחור כאשר אתה מפעיל אותן בעצמך. השתמש ב-/memory בכל עת כדי לעיין במה ש-Grok אחסן.

#איחוד Dream באמצעות /dream

הפקודה /dream מאחדת שברירי זיכרון מפוזרים לנושאים מאורגנים:

/dream

Dream מארגן מחדש יומני הפעלות ורשומות זיכרון נפרדים לבסיס ידע עקבי וללא כפילויות, מה שמפחית רעש ומשפר את איכות החיפוש לאורך זמן. הפקודה /dream דורשת שהזיכרון יהיה מופעל.

#Dream אוטומטי

Dream פועל גם באופן אוטומטי. כברירת מחדל, Grok בודק את תנאי האיחוד בעת ההפעלה ובאופן תקופתי במהלך הפעלה, ומריץ את Dream ברגע שחלף מספיק זמן והצטברו מספיק הפעלות:

[memory.dream]
enabled = true     
# Run automatic consolidation (default: true)
min_hours = 24     
# Minimum hours between consolidations
min_sessions = 5   
# Minimum sessions since the last consolidation
check_interval_secs = 3600 
# Also check the gates hourly

#כיצד הזיכרון משפיע על פרומפטים

#הזרקה בתור הראשון

בתור הראשון של כל הפעלה, Grok מחפש באופן אוטומטי בזיכרון תוכן שרלוונטי לפרויקט הנוכחי ומזריק אותו כהקשר. פירוש הדבר הוא ש-Grok מתחיל עם ידע מהפעלות קודמות ללא צורך בתזכורת.

ניתן להגדיר הזרקה בתור הראשון:

[memory.initial_injection]
enabled = true     
# Enable or disable first-turn injection
min_score = 0.9    
# Score threshold for first-turn injection

#לאחר דחיסה

חיפוש בזיכרון מתבצע גם לאחר דחיסה אוטומטית (compaction), כדי לשחזר הקשר רלוונטי שאולי הושלך.

#חיפוש בזיכרון

Grok מחפש בזיכרון באופן אוטומטי, אך ניתן גם להפעיל חיפושים באופן ידני בצ'אט:

Search memory for "auth middleware patterns"
Read my workspace MEMORY.md

למודל יש גישה לשני כלי זיכרון:

• memory_search: חיפוש בכל הזיכרון
• memory_get: קריאת קובץ זיכרון מסוים לפי נתיב

#ניקוד חיפוש

מודל ה-embedding המוגדר כברירת מחדל אינו מוגדר (unset), ולכן הזיכרון מתחיל במצב של טקסט מלא בלבד. אם תגדיר מודל embedding, החיפוש ישלב דמיון וקטורי (משקל 0.7) עם דמיון טקסטואלי של BM25 (משקל 0.3). התוצאות מסוננות לפי סף ציון מינימלי (ברירת מחדל: 0.7).

#משקלי מקורות

לכל מקור זיכרון יש מכפיל משקל שמוחל על הציון שלו. כל המקורות מוגדרים כברירת מחדל ל-1.0, ותוכל להתאים כל אחד מהם תחת [memory.search.source_weights]:

#דעיכה לאורך זמן

זכרונות מהפעלות דועכים לאורך זמן, כך שלהפעלות אחרונות ניתנת עדיפות:

[memory.search.temporal_decay]
enabled = true           
# Enable time-based decay
half_life_days = 30.0    
# Score halves after this many days

רק מקטעי הפעלות (session chunks) דועכים. זכרונות גלובליים וזכרונות סביבת עבודה פטורים מכך מכיוון שהם מכילים ידע מנוהל לטווח ארוך.

#MMR (Maximal Marginal Relevance)

דירוג מחדש באמצעות MMR קונס תוצאות יתירות כדי לשפר את המגוון:

[memory.search.mmr]
enabled = true           
# Enable diversity re-ranking
lambda = 0.7             
# 0.0 = max diversity, 1.0 = pure relevance

#פקודות CLI

הפקודה grok memory מנהלת את הזיכרון מהמעטפת. יש לה פקודת משנה אחת, clear:

# Clear workspace memory (MEMORY.md, sessions/, and index.sqlite). This is the default scope.
grok memory clear

# The same scope, stated explicitly
grok memory clear --workspace

# Clear the global MEMORY.md
grok memory clear --global

# Clear both workspace and global memory
grok memory clear --all

# Skip the confirmation prompt (-y is the short form)
grok memory clear --yes

כדי לערוך את הזיכרון מהמעטפת, פתח את הקבצים בעורך שלך ישירות, לדוגמה: $EDITOR ~/.grok/memory/MEMORY.md.

#סימוכין לתצורת הגדרות

#הגדרות ליבה ([memory])

#הגדרות אינדקס ([memory.index])

#הגדרות Embedding ([memory.embedding])

#הגדרות חיפוש ([memory.search])

#הגדרות הזרקה ראשונית ([memory.initial_injection])

#הגדרות Dream ([memory.dream])

#הגדרות Flush ([compaction.memory_flush])

הגדרת flush מתבצעת תחת [compaction], ולא תחת [memory], מכיוון שזו התנהגות דחיסה.

#הגדרות גיזום ([compaction.pruning])

הגדרת pruning מתבצעת תחת [compaction], ולא תחת [memory], מכיוון שזו התנהגות דחיסה.

#התיישנות זיכרון

כאשר זיכרון של הפעלה ישן, Grok מצרף אליו הערת התיישנות בתוצאות החיפוש. תוצאות ישנות יותר מקבלות תזכורת בולטת יותר לוודא את המצב הנוכחי לפני שאתה מסתמך עליהן. הערות אלה עוזרות לך לזהות עובדות מאוחסנות שייתכן שאינן מדויקות עוד. זכרונות גלובליים וזכרונות סביבת עבודה לעולם אינם מקבלים הערות התיישנות, מכיוון שהם מכילים ידע מנוהל לטווח ארוך.

#מעקב אחר קבצים

כברירת מחדל, Grok עוקב אחר ~/.grok/memory/ לאיתור שינויים חיצוניים בקבצים. אם אתה עורך קובצי זיכרון ישירות (למשל, בעורך שלך), השינויים נקלטים אוטומטית בחיפוש הזיכרון הבא:

• קבצים שנוצרו או שונו ממופתחים מחדש.
• מקטעים ישנים של קבצים שנמחקו מוסרים מהאינדקס.

[memory.watcher]
enabled = true    
# default

#פתרון בעיות

#הזיכרון לא עובד

1. ודא שהזיכרון מופעל: בדוק את פלט grok inspect.
2. בדוק את GROK_MEMORY או את [memory] enabled בקובץ TOML הקובע.
3. בדוק אם GROK_MEMORY=0 או דגל תאימות שיצא משימוש עוקפים את קובץ התצורה.

#הזיכרון לא מופיע בהפעלות

הזיכרון מוזרק בתור הראשון. אם התחלת הפעלה לפני שהפעלת את הזיכרון, התחל הפעלה חדשה באמצעות /new.

#צפייה בקובצי זיכרון

השתמש ב-/memory ב-TUI כדי לעיין בכל קובצי הזיכרון בליווי תצוגה מקדימה. תוכל לגשת אליהם גם ישירות:

ls ~/.grok/memory/
cat ~/.grok/memory/MEMORY.md
$EDITOR ~/.grok/memory/MEMORY.md

#רישום יומן לצורכי ניפוי שגיאות

RUST_LOG=debug GROK_LOG_FILE=/tmp/grok.log grok
grep "memory" /tmp/grok.log