צ'אטבוט ששואל לקוח לשמו בפעם השלישית באותו שבוע, וסוכן קוד שמכריז שהמשימה הסתיימה כשחצי ממנה עדיין חסר, סובלים מאותה בעיה בדיוק. מודלי שפה הם חסרי מצב (stateless): כל מה שסוכן ״זוכר״ חייב להגיע אליו דרך חלון ההקשר או ממאגר חיצוני. לכן תכנון זיכרון לסוכני AI הוא כבר לא תוספת נחמדה, אלא חלק בסיסי בארכיטקטורה של כל סוכן או צ'אטבוט שאמור לעבוד לאורך זמן.
Anthropic פרסמה מחקר בשם The components of agent memory שמפרק את הנושא לרכיבים ברורים: תמלילים, פתקי זיכרון, ייצוגים מאורגנים, הקשר שנטען לכל שיחה ותהליך רקע של ״חלימה״ שמארגן הכול מחדש. במקביל, פוסט הנדסי של החברה על סוכנים ארוכי טווח הציג דפוס מעשי מבוסס קבצים, שתועד ב-VentureBeat וב-דיון ב-Reddit.
המאמר הזה מסביר את אבני הבניין של Agent Memory, ממפה אותן לכלים מוכרים (Postgres, Supabase, Redis, n8n), ומראה איך מפתחים ובעלי עסקים בישראל יכולים ליישם אותן בצ'אטבוט וואטסאפ, כולל שיקולי פרטיות ועבודה עם טקסט בעברית.
למה סוכנים שוכחים, ואיך Anthropic מגדירה Agent Memory
מודל חסר מצב וחלון הקשר מוגבל
מודל שפה לא שומר דבר בין קריאה לקריאה. כל ״זיכרון״ הוא בפועל טקסט שהמערכת בוחרת להכניס לפרומפט. לפי Mem0, גודל טיפוסי של זיכרון קצר טווח נע בין 8k ל-128k טוקנים, כלומר חלון ההקשר הוא משאב מוגבל ויקר.
הפתרון האינטואיטיבי, לדחוס את כל היסטוריית השיחה לפרומפט, לא עובד טוב. מחקר ״Lost in the Middle״ של Liu ושותפיו, שמצוטט אצל Mem0, הראה שמודלים נוטים להתעלם ממידע שנמצא באמצע הקשר ארוך, ביחס למידע שבתחילתו או בסופו. במילים אחרות, יותר טקסט לא אומר יותר זיכרון, ולפעמים אומר פחות.
מי שכבר עוסק בהנדסת קונטקסט לסוכנים וצ'אטבוטים מכיר את העיקרון: השאלה היא לא כמה להכניס, אלא מה בדיוק להכניס ובאיזה סדר.
שני דפוסי כשל בסוכנים ארוכי טווח
לפי הדיווח ב-VentureBeat, Anthropic זיהתה שני דפוסי כשל עיקריים בסוכנים שעובדים לאורך זמן:
- ניסיון לעשות יותר מדי בבת אחת: הסוכן נכנס למשימה גדולה, נגמר לו חלון ההקשר באמצע, והעבודה נקטעת במצב לא עקבי.
- הכרזה מוקדמת על סיום: הסוכן רואה עקבות של התקדמות קודמת ומסיק שהעבודה הושלמה, למרות שהיא לא.
שני הכשלים האלה הם בעיות זיכרון: הראשון נובע מניהול גרוע של זיכרון העבודה, והשני מהיעדר ייצוג אמין ומובנה של ״מה כבר נעשה ומה נשאר״.
ההגדרה המצומצמת של Anthropic
Anthropic מגדירה זיכרון סוכן כידע ש-Claude רוכש מניסיון, כלומר מאינטראקציות עם משתמשים וממשימות שהוטלו עליו, ושומר בין סשנים בתור הקשר שאפשר לקרוא אותו מאוחר יותר.
חשוב לא פחות מה שההגדרה מוציאה החוצה:
- שינויים במשקלי המודל (fine-tuning) אינם זיכרון במובן הזה.
- למידה בתוך ההקשר (in-context learning) לא נחשבת, כי היא נעלמת בסוף הסשן.
- Compaction, דחיסת השיחה הנוכחית כדי לפנות מקום בחלון, גם היא מחוץ להגדרה.
ההבחנה הזו שימושית מאוד בפועל. היא מבהירה שזיכרון אמיתי הוא משהו ששורד את סוף השיחה, נשמר כטקסט קריא, ואפשר לבדוק אותו, לערוך אותו ולמחוק אותו. זו בדיוק התכונה שמאפשרת גם בקרה וגם עמידה בדרישות פרטיות.
היררכיית הזיכרון: מתמלילים ועד הקשר מוזרק
במחקר Anthropic מתארת היררכיה של ארבע שכבות, מהגולמית ביותר ועד המזוקקת ביותר. כל שכבה עונה על צורך אחר.
תמלילים (Transcripts)
בתחתית ההיררכיה נמצאים התמלילים: יומן אירועים מלא שאפשר לחפש בו. זה המקור הגולמי והמדויק ביותר, אבל גם הרועש והיקר ביותר לשימוש ישיר. בצ'אטבוט וואטסאפ, המקבילה יכולה להיות טבלת ההודעות המלאה: כל הודעה נכנסת ויוצאת עם חותמת זמן.
פתקי זיכרון (Memory notes)
שכבה אחת מעל נמצאים פתקים ש-Claude עצמו כותב. לפי Anthropic, הסוכן יכול לסמן אירועים בולטים ביומן השיחה בזמן שהם קורים, או לכתוב אותם ישירות למאגר זיכרון, למשל תיקייה של קבצי פתקים. בצ'אטבוט עסקי, פתק כזה יכול להיות ״הלקוח מעדיף שיחזרו אליו אחרי 17:00״.
המחקר מעלה כאן שאלה פתוחה ומעניינת: איך שופטים מה בולט וחשוב לפני שיודעים מה יקרה בהמשך? פרט שנראה שולי בהודעה הראשונה עשוי להתברר כקריטי שבוע אחר כך.
ייצוגים (Representations)
השכבה השלישית היא ייצוגים מאורגנים, למשל ויקי. כאן המידע כבר לא רשימה של פתקים בודדים אלא מבנה: דף לכל נושא, קישורים ביניהם. ייצוג כזה קל יותר לשליפה ולתחזוקה, אבל דורש תהליך שבונה ומעדכן אותו.
הקשר מוזרק (Injected context)
בראש ההיררכיה נמצא ההקשר שנטען לכל סשן מראש, בלי שהסוכן צריך לבקש אותו. זה המידע שהכי חשוב לסוכן לדעת תמיד: הנחיות קבועות, העובדות המרכזיות על המשתמש, מצב המשימה הנוכחי. מכיוון שהוא נכנס לכל קריאה, הוא חייב להיות קצר ומדויק.
מיפוי ההיררכיה לצ'אטבוט עסקי
הטבלה הבאה היא דוגמה ליישום אפשרי של ארבע השכבות בצ'אטבוט עסקי. השכבות עצמן לקוחות מהמודל של Anthropic, אבל הדוגמאות והכלים בעמודות הימניות הם הצעה מעשית ולא חלק מהמחקר.
שכבה | מה היא מכילה | דוגמה בצ'אטבוט וואטסאפ | כלי אפשרי (לדוגמה) |
|---|---|---|---|
תמלילים | יומן אירועים מלא | כל ההודעות של הלקוח והבוט | למשל טבלת messages ב-Postgres |
פתקי זיכרון | עובדות שהסוכן כתב | שם, סניף מועדף, שעות נוחות | למשל טבלת user_memory |
ייצוגים | מבנה מאורגן | פרופיל לקוח מסוכם | אפשר למשל עמודת JSON או מסמך פרופיל לכל לקוח |
הקשר מוזרק | מה שנטען תמיד | הנחיות מערכת + 5-10 עובדות מפתח | למשל System prompt שנבנה דינמית |
זיכרון עבודה ומצב שיחה: מה נכנס לחלון ההקשר
זיכרון קצר טווח הוא מה שהסוכן צריך כדי לנהל את השיחה הנוכחית. GreenNode מתארת מודל שכבות נפוץ שמפריד בין זיכרון קצר טווח (הקשר עבודה, באפר סשן, מטמון זמני) לבין זיכרון ארוך טווח, ובמערכות מרובות סוכנים גם זיכרון צוות משותף.
נוסחת ההקשר: סיכום, ההודעות האחרונות ופלטי כלים
ההמלצה המעשית של GreenNode פשוטה: ההקשר שנשלח למודל צריך להיות מורכב מסיכום של מה שקרה עד עכשיו, N ההודעות האחרונות בשיחה ופלטי הכלים החשובים, וכל זה תחת תקציב טוקנים קשיח. כך נמנעים גם מעלויות מיותרות וגם מבעיית ״Lost in the Middle״.
בפועל, תקציב קשיח אומר שיש קוד שמחליט מה נכנס ומה נחתך, ולא משאירים את ההחלטה למזל. הנה דוגמה ל-Code node ב-n8n שבונה הקשר בסדר עדיפויות:
// בניית הקשר תחת תקציב טוקנים קשיח
const MAX_TOKENS = 3000;
// הערכה גסה בלבד: יחס תווים-טוקנים בעברית משתנה בין מודלים
const estimate = (text) => Math.ceil(text.length / 3);
const facts = $('Get Memory').all().map(i => `- ${i.json.fact_key}: ${i.json.fact_value}`);
const summary = $('Get Summary').first()?.json.summary ?? '';
const turns = $('Get Recent Turns').all().map(i => `${i.json.role}: ${i.json.text}`);
// סדר עדיפויות: עובדות מפתח, אחר כך סיכום, ואז ההודעות האחרונות מהחדשה לישנה
const blocks = ['עובדות ידועות:', ...facts, 'סיכום קודם:', summary];
let used = estimate(blocks.join('\n'));
const recent = [];
// עותק של המערך, כדי לא לשנות את המקור
for (const turn of [...turns].reverse()) {
const cost = estimate(turn);
if (used + cost > MAX_TOKENS) break;
recent.unshift(turn);
used += cost;
}
return [{ json: { context: [...blocks, 'שיחה אחרונה:', ...recent].join('\n'), tokens: used } }];שימו לב לשימוש ב-[...turns].reverse() במקום turns.reverse(): הפונקציה reverse משנה את המערך במקום, ועותק מונע תופעות לוואי אם המערך משמש בהמשך. ההערכה לפי אורך תווים היא גסה, ולכן כדאי למדוד את מספר הטוקנים בפועל על הודעות עבריות אמיתיות במודל שבו משתמשים.
איפה שומרים מצב שיחה
מצב השיחה (session state) צריך להיות זמין מהר מאוד. GreenNode מציינת קריאות וכתיבות בזמן של פחות ממילישנייה עם Redis, אבל זו טענה כללית של ספק ולא מדד שנבדק באופן עצמאי. לעומת זאת, לפי Mem0, זמן שליפה של 100 מילישניות ויותר מקובל בזיכרון ארוך טווח.
ב-n8n יש רכיבי זיכרון מובנים כמו Window Buffer Memory. אבל לפי המדריך של Eric Tech, הזיכרון קצר הטווח של n8n מתאפס יחד עם ה-workflow, ולכן הבוט ״שוכח״ את המשתמש בין שיחות. זה בדיוק המקום שבו נדרשת שכבה ארוכת טווח.
פינוי בזיכרון קצר טווח
כשהבאפר מתמלא צריך להחליט מה יוצא. Mem0 מונה שלוש אסטרטגיות נפוצות:
- FIFO: ההודעה הוותיקה ביותר יוצאת ראשונה.
- LRU: מה שלא נעשה בו שימוש לאחרונה יוצא.
- Token trimming: חיתוך לפי תקציב טוקנים, כמו בקוד שלמעלה.
בצ'אטבוט שירות, שילוב של token trimming עם סיכום מתגלגל הוא בחירה הגיונית: ההודעות הישנות לא נמחקות לגמרי, הן נדחסות לסיכום.
זיכרון ארוך טווח לצ'אטבוט: SQL, וקטורים או קבצים
זיכרון ארוך טווח הוא מה שמאפשר לבוט לזהות לקוח חוזר. יש כמה דרכים לממש אותו, ולכל אחת התאמה אחרת.
טבלת עובדות ב-SQL
המדריך של Eric Tech, שפורסם באפריל 2025 וצבר מעל 44 אלף צפיות, בונה זיכרון ארוך טווח לוואטסאפ עם n8n ו-Supabase. ה-AI מסכם אוטומטית את הודעות המשתמש, שומר רק עובדות מפתח בטבלת זיכרון, ושולף אותן עבור הסוכן בכל פנייה.
היתרון לפי המדריך: מבנה מסודר, שליפה מהירה, אינטגרציה קלה עם n8n ויכולת גדילה. החיסרון: צריך לתכנן סכמה ולטפל בעצמכם בעובדות מיושנות ובמחיקה. כדאי לזכור שזו הערכה של יוצר המדריך ולא בנצ'מרק.
וקטורים ו-RAG
טעות נפוצה היא לבלבל בין RAG לבין זיכרון משתמש. לפי אותו מדריך, RAG נועד לשלוף מידע ממסמכים או מבסיס ידע, ולא לשמור פרטים אישיים של משתמש כמו שם. מאגר וקטורי מתאים לשאלות כמו ״מה מדיניות ההחזרות״, ופחות מתאים ל״איך קוראים ללקוח הזה״.
מי שבונה מאגר ידע לצ'אטבוט ימצא הרחבה במאמר על אימות תשובות ב-RAG וציטוטים נגד הזיות.
זיכרון מבוסס קבצים: הגישה של Anthropic לסוכני קוד
בפוסט ההנדסי על סוכנים ארוכי טווח, כפי שסוכם ב-Reddit, Anthropic מתארת harness שבו סוכן מאתחל יוצר קובץ התקדמות, רשימת פיצ'רים בפורמט JSON ו-commit ראשון ב-git. סוכני הקוד שבאים אחריו קוראים את הקבצים ואת ה-git log, ומריצים בדיקת שפיות לפני שהם מתחילים לעבוד.
לפי אותו סיכום, נבחר JSON לרשימת הפיצ'רים כי Claude נוטה פחות לשנות אותו באופן לא הולם מאשר קובץ Markdown, והסוכנים מוגבלים לעבוד על פיצ'ר אחד בכל פעם. חשוב לציין שמדובר בדיווח מיד שנייה. גם Anthropic עצמה הגדירה את הגישה כ״סט אפשרי אחד של פתרונות״, ציינה שלא הוכח אם סוכן כללי אחד או מבנה מרובה סוכנים עובד טוב יותר, וההדגמה כיסתה רק פיתוח אפליקציות ווב full-stack.
הלקח הרחב רלוונטי גם מחוץ לעולם הקוד: מצב משימה שנשמר בפורמט מובנה וקשיח פחות חשוף לשינויים מקריים של המודל, ועשוי לצמצם את כשל ״הכרזה מוקדמת על סיום״.
Google Docs כמאגר זיכרון
תבניות בקהילת n8n מממשות זיכרון ארוך טווח עם Google Docs, באפר חלון להקשר ושמירות עם חותמת זמן, עם Telegram כערוץ. לפי התבנית, הזיכרון נשלף אוטומטית לפני כל אינטראקציה. זה פתרון נוח לאב טיפוס, אבל קשה להפריד בו בין משתמשים ולהרחיב אותו.
טבלת השוואה
גישה | יתרונות | חסרונות | מתאים ל |
|---|---|---|---|
מובנית, מהירה, קלה לחיבור ל-n8n | דורשת סכמה וטיפול עצמאי במחיקה ובתפוגה | צ'אטבוט עם משתמשים רבים | |
No-code, קל לבדיקה ועריכה ידנית | לא מובנה, הפרדה חלשה בין משתמשים, לא מתאים למידע רגיש | אב טיפוס או משתמש יחיד | |
פשוט, בלי מאגר וקטורי, ניתן לביקורת | תוכנן לסוכני קוד, לא לצ'אט מרובה משתמשים | סוכנים ארוכי טווח שמבצעים משימה | |
חיפוש במסמכים ובבסיס ידע | לא מיועד לפרטי משתמש; איכות בעברית תלויה במודל ה-embedding (הערכה כללית) | בסיס ידע עסקי |
שכחה ואיחוד בזיכרון לסוכני AI: Dreaming, סיכום ופינוי
זיכרון שרק גדל הופך עם הזמן לבעיה. Dataiku מנסחת את זה היטב: מה שסוכן זוכר חשוב בדיוק כמו האופן שבו הוא שוכח.
Dreaming: איחוד זיכרון בזמן מנוחה
Anthropic משתמשת בתהליך שהיא מכנה dreaming: בין סשנים, הסוכן עובר על היומנים, מתקן טעויות, יוצר פתקים חדשים, בונה ייצוגים חדשים או משנה את מה שייטען מראש בסשן הבא. התהליך שואב השראה מ-replay בהיפוקמפוס ומאיחוד זיכרונות בזמן שינה, ונשען על עבודה קודמת של Letta ו-UC Berkeley בנושא ״sleep-time compute״.
הרעיון המרכזי: לא כל עבודת הזיכרון צריכה לקרות בזמן אמת, כשהמשתמש מחכה לתשובה. אפשר לדחות חלק ממנה לזמן שבו המערכת פנויה.
חשוב לסייג: פרטי ההערכה והתוצאות שמופיעים במחקר של Anthropic, וכן הפירוט על אופן שיפוט הבולטות ועל מנגנון ה-dreaming עצמו, לא היו זמינים בגרסת העמוד שעליה נשען המאמר. לכן אין כאן נתונים על מידת האפקטיביות של התהליך, ויש להתייחס אליו כרעיון ארכיטקטוני ולא כשיטה מוכחת.
גרסה פשוטה ב-n8n: workflow לילי
הדוגמה הבאה היא פרשנות חופשית של רעיון האיחוד בזמן מנוחה, ולא השיטה שבה Anthropic משתמשת בפועל. בצ'אטבוט עסקי, אפשר למשל לבנות workflow לילי שמופעל ב-Schedule Trigger:
- שליפת כל השיחות שהתעדכנו ב-24 השעות האחרונות.
- שליחת התמליל והעובדות הקיימות למודל, עם בקשה לזהות עובדות חדשות, סתירות ועובדות שפג תוקפן.
- מיזוג עובדות כפולות ועדכון ערכים שהשתנו.
- עדכון הסיכום המתגלגל של כל לקוח.
- סימון עובדות זמניות לתפוגה והעברת תמלילים ישנים לארכיון.
מכיוון ש-workflow לילי שנכשל בשקט יכול להשאיר זיכרון מיושן במשך שבועות, כדאי לחבר אליו ניטור. הרחבה על כך במאמר על ניטור n8n וזיהוי workflow שהפסיק לרוץ.
פינוי בזיכרון ארוך טווח ודפוסי כשל
לפי Mem0, אסטרטגיות הפינוי בזיכרון ארוך טווח שונות מאלו של הזיכרון הקצר: מיזוג (merge), סיכום (summarization) וארכוב (archival). Mem0 מונה גם שלושה דפוסי כשל עיקריים:
- Staleness: עובדות שהיו נכונות והפסיקו להיות, למשל כתובת ישנה.
- Index drift: האינדקס או ה-embeddings כבר לא תואמים לתוכן או למודל הנוכחי.
- Privacy leakage: מידע של משתמש אחד מגיע להקשר של משתמש אחר, או מידע רגיש נשמר כשלא היה צריך.
ממשל נתונים (Governance)
Atlan טוענת שזיכרון ארוך טווח צריך סימני מקור (provenance), אישור ורעננות, כי מידע שגוי נשמר ונשלף בביטחון מלא. לעומת זאת, זיכרון קצר טווח יכול להסתפק בממשל חלש, כי טעויות פגות יחד עם הסשן. זו עמדה של ספק, אבל ההיגיון שלה תקף: עובדה שגויה בזיכרון ארוך טווח תחזור שוב ושוב.
בפועל, אפשר לתרגם את זה לשלוש עמודות פשוטות בכל רשומת זיכרון: מאיזו הודעה העובדה הגיעה, מתי עודכנה לאחרונה, ומה רמת הביטחון בה.
זיכרון לסוכני AI בפועל: צ'אטבוט וואטסאפ ב-n8n
עבור עסקים שמשרתים לקוחות בוואטסאפ, השילוב של n8n ו-Supabase שמוצג במדריך של Eric Tech נותן דפוס מוכן ליישום. מי שעוד לא הקים בוט בסיסי יכול להתחיל מהמדריך להקמת צ'אטבוט בוואטסאפ ולהוסיף עליו את שכבת הזיכרון. הסכמה, הזרימה והפרומפט שבהמשך הם דוגמה מעשית שמבוססת על העקרונות שתוארו, ולא העתק של המדריך.
סכמת הזיכרון
הנה סכמה מינימלית ב-Postgres שמשלבת את עקרונות הממשל שתוארו קודם:
create table user_memory (
id bigserial primary key,
user_id text not null, -- מומלץ hash של מספר הטלפון ולא המספר עצמו
fact_key text not null, -- למשל: name, preferred_branch, contact_hours
fact_value text not null, -- נשמר בשפה שבה המשתמש כתב
source_message_id text, -- מקור העובדה
confidence real default 0.7,
created_at timestamptz default now(),
updated_at timestamptz default now(),
expires_at timestamptz, -- תפוגה לעובדות זמניות
unique (user_id, fact_key)
);
create table conversation_summary (
user_id text primary key,
summary text not null,
updated_at timestamptz default now()
);האילוץ unique על user_id ו-fact_key מונע כפילויות: עובדה חדשה מאותו סוג דורסת את הישנה באמצעות upsert, במקום להצטבר לצידה.
זרימת העבודה
- Webhook נכנס מ-WhatsApp Business API, או למשל דרך ספק תקשורת חיצוני כמו Twilio.
- זיהוי משתמש: חישוב hash למספר הטלפון ושליפת העובדות והסיכום שלו מ-Supabase.
- בניית הקשר עם Code node תחת תקציב טוקנים, כמו בדוגמה שלמעלה.
- AI Agent node שמקבל את ההקשר המוזרק, את ההודעה החדשה ואת הכלים הרלוונטיים.
- שליחת התשובה ללקוח.
- חילוץ עובדות בענף נפרד אחרי שליחת התשובה, כדי לא לעכב את הלקוח.
- Upsert של העובדות החדשות לטבלה ושמירת התמליל.
פרומפט לחילוץ עובדות
השלב הקריטי הוא החלטה מה ראוי להישמר. זו בדיוק שאלת ה-salience שAnthropic מציינת כשאלה פתוחה. פרומפט מפורש עם כללים עוזר לצמצם רעש:
חלץ מהשיחה עובדות מתמשכות על המשתמש. החזר JSON בלבד במבנה:
[{"key": "...", "value": "...", "confidence": 0.0}]
כללים:
- שמור רק עובדות שיהיו רלוונטיות גם בשיחה הבאה (שם, העדפות, סניף, שעות נוחות).
- אל תשמור מספרי תעודת זהות, פרטי אשראי, מידע רפואי או סיסמאות.
- שמור ערכים בשפה ובכתיב שבהם המשתמש כתב אותם. אל תתרגם שמות.
- אם עובדה חדשה סותרת עובדה קיימת, החזר רק את הגרסה החדשה.
- אם אין עובדה חדשה, החזר מערך ריק.
עובדות קיימות:
{{existing_facts}}
שיחה:
{{recent_messages}}כדאי לאמת את הפלט מול סכמה לפני השמירה, כדי שפלט שבור של המודל לא ייכנס למסד הנתונים.
פרטיות ושמירת מידע: זיכרון הוא מידע אישי
ברגע שבוט זוכר שם, כתובת או העדפות, הוא מחזיק מאגר מידע אישי. Dataiku מציינת שזיכרון מתמשך יוצר חובות של שמירת מידע (data retention), ו-Mem0 מונה דליפת פרטיות כאחד מדפוסי הכשל העיקריים של זיכרון ארוך טווח.
בישראל, מי שמפעיל בוט כזה צריך לבחון את חוק הגנת הפרטיות ואת תיקון 13 שלו, ואם יש משתמשים מהאיחוד האירופי, גם את ה-GDPR. המקורות שעליהם נשען המאמר לא עוסקים בדין הישראלי, ולכן מומלץ לאמת את הדרישות מול ייעוץ משפטי. ברמה ההנדסית, כמה עקרונות כמעט תמיד נכונים:
- הסכמה: ליידע את המשתמש שהבוט שומר מידע לשיחות הבאות.
- מחיקה לפי בקשה: פקודה פשוטה כמו ״מחק את המידע שלי״ שמפעילה מחיקה מכל הטבלאות, כולל תמלילים וסיכומים.
- מגבלת שמירה: עמודת expires_at ו-job שמוחק או מארכב מידע ישן.
- מינימום מידע: לשמור רק מה שבאמת משפר את השירות.
- מיקום הנתונים: לבדוק באיזה אזור גיאוגרפי מתארח מסד הנתונים ואיזה ספק LLM מעבד את ההודעות.
להרחבה על שאלות פרטיות מצד ספקי המודלים עצמם, אפשר לעיין במאמר על פרטיות בצ'אטבוטים של AI ואפשרויות opt-out.
בידוד בין משתמשים
במערכת מרובת משתמשים, כל שאילתת זיכרון חייבת להיות מסוננת לפי מזהה המשתמש. ב-Supabase אפשר להוסיף Row Level Security כשכבת הגנה נוספת, כך שגם באג בשאילתה לא יחשוף נתונים של לקוח אחר. מומלץ גם לשמור hash של מספר הטלפון במקום המספר הגלוי, ולהחזיק את המיפוי בטבלה נפרדת עם הרשאות מצומצמות.
עבודה עם טקסט בעברית
המקורות לא מתייחסים לעברית, ולכן הנקודות הבאות הן שיקולים מעשיים שכדאי לבדוק בעצמכם:
- חילוץ עובדות בעברית: לבדוק את פרומפט החילוץ על שיחות אמיתיות, כולל סלנג, קיצורים ושגיאות כתיב.
- שמות מעורבים: לקוחות כותבים שמות בעברית, באנגלית או בשילוב. כדאי לשמור את הכתיב המקורי ולא לתרגם.
- ניקוד ותווים מיוחדים: לנרמל ניקוד וגרשיים לפני השוואה, כדי ש״דוד״ ו״דָּוִד״ לא ייחשבו לשתי עובדות שונות.
- פורמטים מקומיים: מספרי טלפון (05X מול +972), תאריכים בפורמט יום/חודש ושעות בפורמט 24 שעות. כדאי לנרמל לפורמט אחיד לפני השמירה.
- RTL בפלט: טקסט שמשלב עברית עם מספרים או מילים באנגלית עלול להיראות משובש בוואטסאפ. כדאי לבדוק תשובות שמשלבות עובדות מהזיכרון.
- Embeddings: אם משתמשים בחיפוש וקטורי, איכות השליפה תלויה בתמיכה של מודל ה-embedding בעברית. לכן טבלת עובדות מובנית ב-SQL היא לעיתים בחירה בטוחה יותר לפרטי משתמש.
טעויות נפוצות
- שמירת כל ההיסטוריה בפרומפט: מייקר כל קריאה ופוגע בדיוק בגלל אפקט Lost in the Middle.
- שימוש ב-RAG לפרטי משתמש: מאגר מסמכים לא נועד לשמור שם או העדפה אישית.
- הסתמכות על הזיכרון המובנה של n8n בלבד: הוא מתאפס עם ה-workflow.
- אין תפוגה ואין מחיקה: עובדות מיושנות נשלפות בביטחון ומטעות את הבוט.
- חוסר הפרדה בין משתמשים: שאילתה ששוכחת סינון לפי user_id עלולה לחשוף מידע של לקוח אחד ללקוח אחר.
- חילוץ עובדות בנתיב הסינכרוני: מאט את התשובה ללקוח בלי צורך.
- שינוי מערכים במקום בקוד: פונקציות כמו reverse ו-sort משנות את המערך המקורי, ועדיף לעבוד על עותק.
שאלות נפוצות
מה Anthropic מחשיבה כזיכרון סוכן?
לפי Anthropic, זיכרון סוכן הוא ידע ש-Claude רוכש מניסיון, מאינטראקציות עם משתמשים וממשימות, ושומר בין סשנים כהקשר קריא. שינויים במשקלי המודל, למידה בתוך ההקשר ו-compaction אינם נכללים בהגדרה.
מה זה dreaming בזיכרון של סוכני AI?
תהליך שבו הסוכן מנצל זמן פנוי כדי לעבור על יומנים, לתקן טעויות וליצור פתקים או ייצוגים חדשים. ההשראה היא איחוד זיכרונות בזמן שינה, והגישה נשענת על מחקר sleep-time compute של Letta ו-UC Berkeley. ב-n8n אפשר לממש רעיון דומה בגרסה פשוטה כ-workflow לילי, אבל זו פרשנות ולא השיטה של Anthropic.
למה הזיכרון המובנה של n8n לא מספיק לבוט וואטסאפ?
לפי המדריך של Eric Tech, הזיכרון קצר הטווח של n8n מתאפס עם ה-workflow, ולכן הבוט שוכח את המשתמש בין שיחות. כדי שהבוט יזהה לקוח חוזר צריך מאגר מתמשך שמחזיק עובדות מפתח.
האם RAG זה אותו דבר כמו זיכרון משתמש?
לא. RAG שולף מידע ממסמכים ומבסיס ידע, ולפי המדריך הוא לא מיועד לפרטים אישיים כמו שם המשתמש. זיכרון משתמש נשמר טוב יותר כטבלת עובדות מובנית לפי מזהה משתמש.
למה לא פשוט לשמור את כל ההיסטוריה בפרומפט?
כי זה מעלה את עלות הטוקנים ואת זמן התגובה, ומודלים נוטים להתעלם ממידע שנמצא באמצע הקשר ארוך. GreenNode ממליצה על סיכום, N ההודעות האחרונות ופלטי כלים חשובים תחת תקציב טוקנים קשיח.
מה הסיכונים של זיכרון ארוך טווח לצ'אטבוט?
עובדות מיושנות או שגויות נשמרות ונשלפות בביטחון, כפי שAtlan מציינת. בנוסף, זיכרון מתמשך יוצר חובות שמירת מידע וסיכון לדליפת פרטיות, ולכן צריך תפוגה, מחיקה לפי בקשה ובידוד בין משתמשים.
סיכום
זיכרון לסוכני AI הוא לא רכיב אחד אלא מערכת של שכבות. המחקר של Anthropic מספק מסגרת חשיבה ברורה: תמלילים גולמיים בתחתית, פתקי זיכרון וייצוגים מאורגנים באמצע, והקשר מוזרק וקצר בראש, עם תהליך רקע שמאחד, מתקן ושוכח. ההגדרה המצומצמת שלה, ידע קריא שנשמר בין סשנים, מבהירה גם מה צריך לנהל, לבדוק ולמחוק.
בצד המעשי, דפוס אפשרי לצ'אטבוט וואטסאפ ב-n8n פשוט יחסית: באפר קצר עם תקציב טוקנים לשיחה הנוכחית, טבלת עובדות ב-SQL לזיכרון ארוך טווח, חילוץ עובדות אסינכרוני ו-workflow לילי לאיחוד ולפינוי. כדאי לזכור ש-Anthropic עצמה הציגה את הגישה שלה כאפשרות אחת ולא כפתרון סופי, שפרטי ההערכה של המחקר לא היו זמינים, ושחלק מהמקורות בתחום הם ספקים עם אינטרס.
למפתחים בישראל נוספות שתי שכבות אחריות: בדיקת חילוץ ושליפה על טקסט עברי אמיתי, ותכנון פרטיות מהיום הראשון, כולל הסכמה, מחיקה ומגבלות שמירה. זיכרון טוב הוא זיכרון שיודע גם מה לשכוח.
מקורות
- The components of agent memory – Anthropic
- Anthropic says it solved the long-running AI agent problem – VentureBeat
- Anthropic shares an approach to agent memory – Reddit r/AIMemory
- AI Chatbot That Remembers You! (n8n + Supabase + WhatsApp) – Eric Tech
- Memory Architecture for Multi-Agent Systems – GreenNode
- Short-Term vs Long-Term Memory in AI – Mem0
- AI agent memory: types, architectures, enterprise considerations – Dataiku
- Long-Term vs Short-Term AI Memory – Atlan
- n8n template: AI agent chatbot + long-term memory + Telegram
- n8n template: AI chatbot with long-term memory and dynamic tool routing






