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

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

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

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

גרסה 0.4.0 של Recall, ששוחררה ב-18 ביולי 2026, היא עדיין הגרסה העדכנית ביותר נכון לאוקטובר 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 מסיים תגובה. הוא מצרף את אותו סבב ליומן (log).
• SessionEnd מופעל כאשר הסשן נסגר, ויכול ליצור מחדש את הסיכום.

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

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

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

ls -la .recall/

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

/recall:save

פקודה זו מריצה את מסכם הנתונים המקומי על 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 חוסך ב־tokens?

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

[
  {
    "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 tokens, נתון שתואם להצהרה המפורסמת של הפרויקט על אלף עד אלפיים tokens עבור שחזור (resume). טעינה מחדש של תמלול קודם מלא טוענת את כל השיחה, באזור ה־85,000 tokens. מתן אפשרות למודל לגלות את הפרויקט מחדש על ידי קריאת קבצים נמצא בין שני הערכים, קרוב ל־30,000 tokens, ומספר זה גדל ככל שה־repository גדל. השורה CLAUDE.md נועדה להמחשת קנה מידה: היא זולה יותר כיוון שהיא קצרה וסטטית, והיא מציגה למודל את הכללים הקבועים שלכם במקום את מה שקרה אמש.

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

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

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

סייג אחד שומר על הגינות הטענה הזו. הסיכום נטען בכל תחילת סשן, לכן סיכום שאתם לעולם לא פועלים לפיו הוא מס קטן ולא חיסכון. השאירו את 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, לכן סביבה שבה אף אחד מהם לא קיים תיכשל עם stderr וקוד יציאה 127. Claude Code מציג התראת שגיאת hook לא חוסמת המכילה את השורה הראשונה של ה־stderr.

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

הקבצים מופיעים תחת הפרויקט הלא נכון. 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. הכלי אינו מספק סנכרון בזמן אמת: שני סשנים באותו פרויקט חולקים את אותו קובץ יומן, אך Recall אינו דוחף רשומות יומן חדשות להקשר של הסשן האחר. לכן, כאשר סשן אחד צריך לדעת מה האחר עושה, סשנים יכולים להעביר טקסט ביניהם ישירות בזמן שהם רצים.

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

הסיכום מטופל כקלט לא מהימן כחלק מהתכנון. context.md מוזרק כשהוא מוקף בסימני גבול ומסומן, ו-Claude מבקש אישור לפני שהוא מסתמך עליו. תכנון זה קיים מכיוון שספריית .recall/ שבוצעה לה commit היא מקום שבו לכל בעל הרשאות כתיבה יש אפשרות להוסיף טקסט שהסוכן שלכם יקרא. מידת העצירה של הסוכן כדי לשאול על מה שהוא קורא נקבעת לפי מצב ההרשאות שבו הסשן מתחיל. החל מ-Claude Code v2.1.283 ומעלה, מצב auto הוא כבר מצב ברירת המחדל המובנה עבור סשנים בטרמינל אינטראקטיבי וב-VS Code בכל תוכנית וספק, כך שסיווג (classifier) ולא אתם הוא זה שבוחן את רוב הפעולות; ארגונים עם תצורת HIPAA עדיין מתחילים במצב Manual. החליטו פעם אחת האם .recall/ הוא אישי או משותף: הוסיפו אותו ל-.gitignore עבור זיכרון אישי, או בצעו לו commit ובחנו אותו כמו כל תרומה אחרת. אם הסוכן רץ ללא השגחה, הרצת Claude Code בצורה בטוחה על גבי VPS מכסה את הגבולות הרחבים יותר.

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

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

FAQ

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

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

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

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

כמה Recall חוסך בכל סשן?

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

האם אני עדיין זקוק לקובץ CLAUDE.md?

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

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

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