הוספת זיכרון ל-Claude Code בעזרת תוסף Recall על VPS

מה Recall עושה עבור הזיכרון של Claude Code

Recall הוא תוסף עבור Claude Code המעניק לכל פרויקט זיכרון בין סשנים שונים. הוא כותב שני קובצי markdown לתוך תיקיית .recall/ בתוך הפרויקט שלך: יומן המיועד להוספה בלבד (append-only) של האירועים שהתרחשו, וסיכום קצר של הנקודה שבה עצרת. שני הקבצים מופקים על המכונה שבה אתה עובד באמצעות מסכם Python מקומי, כך שהזיכרון עצמו אינו צורך אסימוני API כלל.

הפער שהוא מגשר עליו הוא קטן וקבוע. אתה סוגר סשן ב-VPS שלך ביום שלישי. ביום רביעי, Claude Code אינו יודע דבר על יום שלישי. אתה מסביר את הפרויקט מחדש באופן ידני, או שאתה נותן למודל לקרוא חצי מה-repository שוב כדי להבין את המצב. שתי הפעולות עולות אסימונים, והשנייה עולה כמות גדולה מאוד שלהם.

גרסה 0.4.0 של Recall היא הגרסה העדכנית נכון ליולי 2026, והפרויקט מופץ תחת רישיון MIT. זהו תוסף. שום דבר בו אינו מבצע קריאת רשת.

דרישות המערכת ב-VPS

סקריפטי ה-capture hooks של Recall מגיעים יחד עם התוסף. אין תלויות של צד שלישי, לכן הדרישה היחידה היא מפרש (interpreter).

python3 -V

Ubuntu 24.04 מספקת את Python 3.12.3. Recall תומך ב-Python 3.9 ומעלה. תמונות מכולה (container images) מינימליות לעיתים אינן כוללות מפרש כלל, ובמקרה כזה ה-shell יחזיר python3: command not found. יש להתקין מפרש לפני שממשיכים.

sudo apt update && sudo apt install -y python3

NumPy הוא מאיץ אופציונלי עבור שלב אחד ב-summarizer. אין חובה להשתמש בו.

python3 -c "import numpy"

ModuleNotFoundError: No module named 'numpy' הוא תשובה קבילה כאן. ל-summarizer יש נתיב המבוסס על Python טהור, וחבילת הבדיקות של הפרויקט מוודאת ששני הנתיבים בוחרים את אותם המשפטים.

זיכרון סשן חשוב יותר בשרת מאשר במחשב נייד, כיוון שעבודה בשרת מגיעה בביקורים קצרים הפרוסים על פני ימים. אם כבר יש לך Claude Code רץ בתוך tmux על גבי VPS, Recall הוא הרכיב שמעביר את הסשן של אתמול אל היום.

התקנת Recall מתוך ה-marketplace של התוספים

שתי פקודות, להקלדה בתוך סשן של Claude Code:

/plugin marketplace add raiyanyahya/recall
/plugin install recall@recall

הפקודה השנייה קוראת ל-plugin@marketplace. שני השמות הם recall כאן, מה שנראה כמו טעות העתק-הדבק אך אינו כזה.

בדקו את ההתקנה על ידי הרצת אחת הפקודות של התוסף עצמו:

/recall:show

/recall:show מדפיס את הסיכום הנוכחי. בפרויקט חדש לגמרי אין עדיין מה להדפיס, לכן מה שאתם בודקים בפועל הוא שהפקודה קיימת. אם Claude Code לא מזהה את /recall:show, התוסף לא נטען ושום hook לא יופעל.

כדי להריץ מתוך checkout במקום זאת, שכפלו את ה-repository ובדקו אותו תחילה:

git clone https://github.com/raiyanyahya/recall ~/recall
cd ~/recall && claude plugin validate .

claude plugin validate . קורא את ה-manifest ב-.claude-plugin/ ומדווח אם התוסף בנוי כראוי. לאחר מכן, הפעילו את Claude Code מתוך ספריית הפרויקט שלכם עם claude --plugin-dir ~/recall.

מה ה-hooks כותבים ומתי

Recall רושם שלושה hooks עבור Claude Code. כל אחד מהם מריץ סקריפט Python מתוך ספריית ה-plugin.

• SessionStart מופעל בעת עלייה (startup), המשך (resume) וניקוי (clear). הוא מציג את context.md כך שהסשן נפתח כשהסיכום שלך גלוי.
• Stop מופעל בכל פעם ש-Claude מסיים תגובה. הוא מצרף את אותו סבב ללוג.
• SessionEnd מופעל כאשר הסשן נסגר, ויכול ליצור מחדש את הסיכום.

שני קבצים נוצרים כתוצאה מכך, שניהם בתוך .recall/.

• history.md הוא התיעוד שניתן רק להוסיף אליו (append-only): פרומפטים, תגובות, קבצים שבהם בוצע שימוש ופקודות שהורצו.
• context.md הוא התמצית שנוצרה: המטרה, סיכום, צעדים הבאים, קבצים שבהם בוצע שימוש, פקודות שהורצו והקשר ה-git.

לאחר סשן אחד אמיתי, בדוק את הספרייה.

ls -la .recall/

אתה אמור לראות את history.md עם תוכן בתוכו. ייתכן שלא תראה את context.md כלל, וזו התנהגות ברירת המחדל ולא תקלה. auto_save_context הוא off אלא אם הגדרת אותו, לכן הסיכום נכתב רק כאשר אתה מבקש זאת:

/recall:save

פקודה זו מריצה את ה-summarizer המקומי על history.md וכותבת מחדש את context.md. האלגוריתם הוא TF-IDF (תדירות מונח, תדירות מסמך הפוכה) המזין דירוג משפטים מסוג TextRank. הוא דטרמיניסטי ותמציתי (extractive), כלומר הוא בוחר משפטים שכבר קיימים בלוג שלך. שום מודל אינו נקרא, לכן השלב הוא חינמי ועובד כשהמכונה במצב offline.

הגדרת Recall עבור פרויקט בודד

התצורה נמצאת בקובץ recall.config.json בשורש הפרויקט. להלן ברירות המחדל שמגיעות עם התוכנה:

{
  "output_dir": ".recall",
  "capture_history": true,
  "summary_sentences": 8,
  "redact": true,
  "include_git": true,
  "max_input_chars": 200000
}

• output_dir מגדיר היכן נשמרים שני הקבצים. מומלץ להשאירם בתוך הפרויקט.
• capture_history מפעיל או מכבה את הלוג history.md.
• auto_save_context מקבל את הערכים off או on_end, כאשר ברירת המחדל היא off.
• summary_sentences קובע כמה משפטים יישמרו בתוך context.md. העלאת ערך זה תייצר סיכום ארוך יותר ותגדיל מעט את העומס בתחילת הסשן.
• redact מסיר תבניות נפוצות של סודות לפני כתיבת נתונים לדיסק.
• include_git מוסיף את ה-diff הנוכחי ואת ה-commits האחרונים לסיכום.
• max_input_chars מגביל את כמות הנתונים מתוך history.md שהמסכם קורא במעבר אחד.

עבור פרויקט ב-VPS, השינוי השימושי הוא הפעלת שמירה אוטומטית, כיוון שסשן בשרת מסתיים לעיתים קרובות כאשר הטרמינל נסגר, ולא כאשר המשתמש בוחר להפסיק.

{
  "auto_save_context": "on_end",
  "summary_sentences": 12
}

כדי לעצור את הלכידה לזמן מה מבלי לשנות את קובץ התצורה, צרו את קובץ סימון ההשהיה. מחקו אותו כדי להתחיל בלכידה מחדש.

touch .recall/.capture-paused

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

כמה Recall חוסך בטוקנים?

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

[
  {
    "label": "Recall context.md",
    "char_count": "4,800",
    "est_tokens": "1,200"
  },
  {
    "label": "Hand-written CLAUDE.md",
    "char_count": "3,200",
    "est_tokens": "800"
  },
  {
    "label": "Re-reading the repo",
    "char_count": "120,000",
    "est_tokens": "30,000"
  },
  {
    "label": "Full transcript replay",
    "char_count": "340,000",
    "est_tokens": "85,000"
  }
]

אלו נתונים טיפוסיים לפרויקט בגודל בינוני, ולא מדידה של הפרויקט שלכם. סיכום של Recall נטען בערך ב-1,200 טוקנים, נתון שתואם להצהרה שפורסמה עבור הפרויקט של אלף עד אלפיים טוקנים עבור resume. הפעלה מחדש של תמלול קודם מלא טוענת את כל השיחה, בטווח של 85,000 טוקנים. מתן אפשרות למודל לגלות מחדש את הפרויקט על ידי קריאת קבצים נמצא בין שני הערכים הללו, קרוב ל-30,000 טוקנים, ומספר זה גדל ככל שה-repository גדל. השורה CLAUDE.md מופיעה לצורך קנה מידה: היא זולה יותר כיוון שהיא קצרה וסטטית, והיא מציגה למודל את הכללים הקבועים שלכם במקום את מה שקרה אמש.

מדדו את המספרים שלכם. טוקן אחד הוא בערך ארבעה תווים של פרוזה באנגלית, וקצת פחות עבור קוד. אם אתם מזינים את הסיכום גם למודל מקומי על אותו ה-VPS, בדקו את ה-window שבו הוא נוחת לפני שאתם סומכים על ה-resume, כיוון ש-Ollama קוטע prompts ארוכים באורך context ברירת מחדל קטן במקום להודיע לכם שהוא השמיט את הסוף.

wc -c .recall/context.md .recall/history.md
echo $(( $(wc -c < .recall/context.md) / 4 ))

בתוך סשן, /context מציג מה טעון ב-context window כרגע, ו-/cost מדווח על סכומי הסשן. התחילו סשן אחד "קר", התחילו את הבא עם סיכום פעיל, והשוו. לתמונה המלאה של לאן הולכים הטוקנים של סשן בפועל, איך Claude Code מוציא טוקנים מכיל את הפירוט.

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

בנייה מחדש של הסיכום ללא סשן

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

python3 ~/recall/scripts/make_context.py --help

פלט העזרה מפרט את הדגלים הנתמכים: --cwd עבור שורש הפרויקט, --transcript עבור קובץ תמלול מפורש, --quiet לדיכוי הפלט, ו---harness לבחירה בין claude ל-opencode. הפנו את הפקודה אל פרויקט:

python3 ~/recall/scripts/make_context.py --cwd /srv/projects/api

הכלי קורא את תמלול הסשן ואת history.md, ולאחר מכן כותב את context.md תחת הספרייה שציינתם. אם התקנתם דרך ה-marketplace, התוסף נמצא בספרייה שמנוהלת על ידי Claude Code, ו-/recall:save היא הדרך הנתמכת לביצוע אותה פעולה.

מדוע לא נכתב דבר

אין ספריית .recall/ לאחר סיום סשן מלא. ה-hooks לא הופעלו. הקלידו /recall:show כדי לוודא שהתוסף טעון, ולאחר מכן הריצו את python3 -V. פקודת ה-hook מנסה להשתמש ב-python3 תחילה וב-python לאחר מכן, לכן מערכת שבה אף אחד מהם אינו קיים לא תכתוב דבר ולא תציג התראה על כך.

הקובץ history.md גדל אך context.md אינו משתנה. הערך auto_save_context מוגדר כ-off כברירת מחדל. הריצו את /recall:save, או הגדירו את המפתח ל-on_end ואפשרו ל-hook מסוג SessionEnd לבצע זאת.

הקבצים מופיעים תחת הפרויקט הלא נכון. הכלי Recall כותב יחסית לספרייה שבה הופעל Claude Code, לכן התחלת סשן מתיקיית הבית שלכם תמקם את הזיכרון שם. התחילו מתיקיית השורש של הפרויקט, והשתמשו ב-ls -la .recall/ כדי למצוא היכן הקבצים נשמרו בפועל.

הלכידה נעצרה ולא קיבלתם אזהרה. בדקו אם קיים סמן השהיה באמצעות ls -a .recall/. ייתכן שקובץ .capture-paused שיצרתם בשבוע שעבר עדיין פעיל.

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

mv .recall/history.md .recall/history-2026-07-30.md

הריצו סשן קצר אחד לאחר מכן ובדקו שוב את ls -la .recall/ כדי לוודא שנוצר קובץ history.md חדש.

היכן נעצר Recall

Recall הוא יומן בצירוף מסכם, וחשוב להבהיר מה הוא אינו כולל.

המסכם הוא מסוג extractive. האלגוריתם TextRank בוחר משפטים שכבר קיימים ב-history.md, לכן הוא לעולם אינו שופט אם החלטה הייתה נכונה. פנייה שגויה שתועדה ביום שלישי נראית בדיוק כמו החלטה טובה ביום רביעי. כאשר מדובר בנושאים קריטיים, קראו את context.md ותקנו אותו ידנית. זהו קובץ markdown ושום דבר לא מונע מכם לערוך אותו.

אין מנגנון חיפוש. אתם מקבלים סיכום עדכני אחד ויומן אחד שגדל עבור כל פרויקט, ולא זיכרון שניתן לשאילתות בין פרויקטים שונים. אם השאלה היא מה החלטתם לגבי מסד הנתונים לפני שלושה שבועות, עליכם להשתמש ב-grep על history.md. המערכת גם לא מעבירה מידע הצידה: שני sessions שפתוחים על אותו VPS בו-זמנית אינם יכולים לראות את היומנים זה של זה, לכן כאשר אחד צריך לדעת מה השני עושה, sessions יכולים להעביר טקסט ביניהם ישירות בזמן שהם רצים.

הכלי אינו מסייע בתוך session. חלון הקשר (context window) שמתמלא באמצע session הוא בעיה שונה עם פתרונות שונים, ו-ניהול חלון ההקשר בתוך session אחד הוא המדריך המשלים למדריך זה.

הסיכום מטופל כקלט לא מהימן כחלק מהתכנון. context.md מוזרק כשהוא תום בתוך בלוק ומסומן, ו-Claude שואל לפני שהוא מסתמך עליו. תכנון זה קיים מכיוון שספריית .recall/ שבוצעה לה commit היא מקום שבו לכל מי שיש לו גישת commit יכול לכתוב טקסט שהסוכן שלכם יקרא. מידת העצירה של הסוכן כדי לשאול על מה שהוא קורא נקבעת לפי מצב ההרשאות שבו ה-session מתחיל, ו-מצב auto הופך לברירת המחדל ב-Claude Code ב-14 באוגוסט 2026. החליטו פעם אחת אם .recall/ הוא אישי או משותף: הוסיפו אותו ל-.gitignore עבור זיכרון אישי, או בצעו לו commit ובדקו אותו כמו כל תרומה אחרת. אם הסוכן רץ ללא השגחה, הרצת Claude Code בצורה בטוחה על VPS מכסה את הגבולות הרחבים יותר.

הסתרת מידע (redaction) היא במאמץ מיטבי בלבד. היא מכוונת לתבניות נפוצות כגון API keys, אסימונים, בלוקים של PEM והשמות של .env. קראו את .recall/ לפני שאתם מבצעים לו commit.

מספר הגרסה משקף נאמנה את רמת הבשלות. בגרסה 0.4.0 ביולי 2026, מפתחות התצורה ומבנה הקבצים עדיין יכולים להשתנות בין releases, לכן קראו את יומן השינויים (changelog) לפני שאתם משדרגים הגדרה שאתם תלויים בה.

FAQ

האם Recall שולח את הקוד או את התמלילים שלי למקום כלשהו?

לא. ה-hooks של הלכידה והמסכם הם סקריפטים ב-Python שרצים על המכונה שלך. התוסף אינו מחזיק מפתח API והוא אינו מבצע קריאות רשת. הסיכום משתמש ב-TF-IDF וב-TextRank במקום במודל, לכן השלב אינו כרוך בעלות ועובד גם כשהמכונה במצב offline. החיסרון הוא שהסיכום הוא תמציתי (extractive): הוא בוחר משפטים מתוך ה-log שלך במקום לכתוב משפטים חדשים.

מדוע ה-.recall/context.md שלי חסר או לא מעודכן?

ברירת המחדל של auto_save_context היא off, לכן הסיכום נוצר מחדש רק כאשר מריצים את /recall:save. הגדירו את "auto_save_context": "on_end" בתוך recall.config.json כדי שהסיכום ייכתב מחדש בכל סיום של session. אם גם history.md חסר, ה-hooks אינם רצים כלל: ודאו שהתוסף טעון באמצעות /recall:show, ולאחר מכן ודאו ש-python3 -V מגיב על אותה מכונה, שכן ה-hooks הם סקריפטים ב-Python.

כמה Recall חוסך בכל session?

טעינת סיכום עולה כ-1,200 טוקנים, לעומת 30,000 טוקנים בממוצע עבור מודל שצריך לקרוא את ה-repository שלך שוב כדי להבין היכן הוא נמצא. אלו נתונים טיפוסיים. מדדו את הנתונים שלכם באמצעות wc -c .recall/context.md והפקודה /context בתוך ה-session, והשוו בין התחלה קרה (cold start) לבין המשך עבודה מתוך סיכום.

האם אני עדיין צריך קובץ CLAUDE.md?

כן, לשניהם יש תפקידים שונים. CLAUDE.md הוא מה שאתם כותבים במכוון: הכללים הקבועים ופקודות ה-build. context.md נוצר ממה שקרה בפועל ב-session האחרון, לכן הוא מכיל את המיגרציה החלקית שלעולם לא הייתם חושבים לתעד. שמרו את שניהם.

האם VPS אחד יכול להחזיק זיכרון עבור כמה פרויקטים?

כן. Recall שומר את הזיכרון ב-.recall/ בתוך תיקיית כל פרויקט, לכן שני פרויקטים על אותו שרת מחזיקים logs נפרדים וסיכומים נפרדים. הפעילו את Claude Code מתוך ה-root של הפרויקט בכל פעם, כיוון שהקבצים עוקבים אחרי תיקיית העבודה ולא אחרי חשבון המשתמש.