איך זיכרון של סוכן AI באמת עובד (ולמה רוב הסוכנים שוכחים הכול)
זיכרון של סוכן AI הוא ההבדל בין סוכן שמצטבר על עבודת עבר לבין סוכן שמתחיל מאפס בכל קריאה. הנה איך אני חושב על ארבעת סוגי הזיכרון, מה אני באמת משלח, ולמה חלונות הקשר הם לא זיכרון.
לרוב סוכני ה-AI אין זיכרון. הם מבריקים לשיחה אחת וחסרי זיכרון בבאה אחריה. אתם בונים משהו, זה עובד, אתם מתרשמים - ואז אתם קוראים לזה שוב וזה מתנהג כאילו מעולם לא נפגשנו.
זה לא באג במודל. זה כשל עיצוב. וזה כשל שעשיתי יותר פעמים ממה שהייתי רוצה להודות.
הנה איך זיכרון של סוכן AI באמת עובד, מהם ארבעת הסוגים, ומה אני באמת משלח בפרודקשן - מבוסס על מערכות אמיתיות שבניתי, כולל ctxauditor, LLM Cost Lens, ומערכת שבעת הסוכנים שמפעילה את האתר הזה.
חלון ההקשר הוא לא זיכרון
מתחילים כאן, כי כאן רוב האנשים טועים.
כשמודל מעבד את הבקשה שלכם, הוא רואה חלון הקשר - באפר גדול שטוח של טוקנים: system prompt, היסטוריית שיחה, תוצאות כלים, מה שדחפתם לשם. המודל חסר מצב. הוא לא זוכר את הקריאה הקודמת. הוא קורא את הבאפר, מייצר תגובה, ושוכח הכול.
חלון ההקשר מרגיש כמו זיכרון כשאתם בתוך שיחה רצה. אתם אומרים משהו בסיבוב 3, המודל מתייחס אליו בסיבוב 7, וזה נראה כאילו הוא "זכר". אבל הוא לא. אתם (או שכבת התזמור שלכם) כללתם את סיבוב 3 בבאפר עבור סיבוב 7. המודל פשוט קרא אותו.
ההבחנה הזו חשובה עד מאוד כשאתם בונים סוכנים שרצים שעות, שמתעוררים על לוח זמנים, או שמתאמים עם סוכנים אחרים. אם תטעו לחשוב שחלון ההקשר הוא זיכרון מתמשך, תבנו מערכות שעובדות בדמו ונשברות בפרודקשן.
למדתי את זה בדרך הקשה תוך בניית ctxauditor - כלי שאני משתמש בו לבקר את חלונות ההקשר של הסוכנים שלי. לגרסה הראשונה לא הייתה שכבת שמירה בכלל. היא יכלה לענות "כמה טוקנים ההקשר הזה?" אבל לא יכלה להגיד שום דבר על ההקשרים של אתמול. כל ההיסטוריה התפעולית הזו, נעלמה. תקנו אותי - היא לא נעלמה, היא מעולם לא נאחסנה. מעולם לא אמרתי לה לאחסן.
ארבעת סוגי הזיכרון של סוכן
יש כאן טקסונומיה נקייה. לא המצאתי אותה - צוות המחקר של Anthropic וכמה אחרים התכנסו לבערך אותה מסגרת. אסביר אותה במונחים של מה שבאמת בונים.
1. זיכרון בתוך-הקשר
זה הבאפר. כל דבר שאתם שמים בחלון ההקשר עבור הקריאה הנוכחית הוא "זיכרון בתוך-הקשר". הוא מהיר, הוא קוהרנטי, הוא זמין מיד - והוא נעלם ברגע שהקריאה מסתיימת.
זיכרון בתוך-הקשר נהדר ל: המשימה הנוכחית, סיבובי שיחה אחרונים, תוצאות כלים שאתם מסיקים עליהן באופן פעיל.
הוא נורא ל: כל דבר שצריך להתמיד על פני קריאות, כל דבר שגדל בלי גבול לאורך זמן.
מצב הכשל שאני רואה הכי הרבה: מפתחים מנסים לפתור שמירה על ידי דחיסת עוד ועוד היסטוריה לתוך ההקשר. ראיתי חלונות הקשר מתנפחים מ-8 אלף ל-200 אלף טוקנים רק כי מישהו לא רצה לבנות שכבת זיכרון אמיתית. העלות מצטברת מהר. LLM Cost Lens הראה לי, בפרויקט אחד, ש-67% מהוצאת הטוקנים שלי הייתה על הקשר שחזרתי עליו בכל קריאה - היסטוריית שיחה ישנה שהסוכן כמעט לא הזדקק לה.
2. זיכרון חיצוני (שליפה)
זה מסד הנתונים שלכם. חנויות וקטוריות, חנויות מפתח-ערך, SQL, מה שמתאים לדפוס הגישה. זיכרון חיצוני מתמיד על פני קריאות, יכול להסתכלל למיליוני רשומות, ולא אוכל את תקציב ההקשר שלכם עד זמן השליפה.
המודל המנטלי: תחשבו על זה כמו מנוע חיפוש שהסוכן יכול לשאול. במקום לקרוא כל אינטראקציית עבר, הסוכן מחפש את הרלוונטיות. רק תוצאות ה-top-k נכנסות לחלון ההקשר.
כאן מסדי נתונים וקטוריים נכנסים. אני משתמש בהם ל: סיכומי שיחות עבר, בסיסי ידע, תוצרים קודמים שהסוכן עלול להזדקק להתייחס אליהם, היסטוריית קריאות כלים. צעד השליפה מוסיף חביון - בדרך כלל 50-200 אלפיות שנייה - ששווה לעקוב אחריו אבל לעיתים נדירות הוא צוואר הבקבוק.
דבר אחד שטעיתי בו במשך בערך שבוע: הנחתי ש"יותר צ'אנקים שנשלפו = יותר טוב". שלפתי תוצאות top-20, חשבתי יותר הקשר = ביצועים טובים יותר. ההפך היה נכון. דיוק חשוב יותר מכיסוי בזמן שליפה. כשחלון ההקשר מוצף בצ'אנקים רלוונטיים-בקושי, תשומת הלב של המודל מתפזרת. קיצצתי ל-top-3 לרוב קריאות השליפה והדיוק עלה.
3. זיכרון בתוך-משקלים (ידע המודל)
את זה אתם לא שולטים בזמן ההסקה. זה מה שהמודל למד במהלך האימון: איך לקודד, ידע כללי על העולם, דפוסי שפה. זה אפוי בפנים.
אתם יכולים להשפיע על זה בכיוונון עדין (fine-tuning), אבל זו שיחה נפרדת. לרוב סוכני הפרודקשן, אתם עובדים עם מודל בסיס ומקבלים את מה שהוא יודע כנתון.
מה זה אומר מעשית: אל תשתמשו בזיכרון חיצוני כדי ללמד את הסוכן דברים שהוא כבר יודע (תחביר Python, פורמט JSON). כן תשתמשו בזיכרון חיצוני לדברים שהמודל לא יכול היה לדעת: נתוני המערכת הספציפיים שלכם, אינטראקציות עבר, עובדות ספציפיות-לתחום על העסק שלכם.
4. זיכרון בתוך-מטמון (KV Cache)
זה הסוג שרוב המפתחים לא חושבים עליו, וכאן חיים חסכונות עלות רציניים.
כשאתם שולחים בקשה ל-Claude (או כל מודל מבוסס-transformer), המודל מחשב זוגות מפתח-ערך לכל טוקן בהקשר. אם אתם שולחים את אותה קידומת בכל קריאה - אותו system prompt, אותן הגדרות כלים - חישובי ה-KV האלה מיותרים.
Prompt caching (שכיסיתי במאמר נפרד) נותן לכם להגיד ל-API: "שמור מטמון מכאן". הקידומת השמורה לא מחושבת מחדש. בקריאות חוזרות עם אותה קידומת, אתם משלמים כ-10% מהעלות הרגילה עבור הטוקנים האלה.
במערכת שבעת הסוכנים שלי, סוכנים חולקים system prompt של 4,000 טוקנים שמגדיר את סביבת העבודה. אני מנעץ את זה למטמון. בימי נפח גבוה - 200+ קריאות סוכן - ההחלטה הבודדת הזו חוסכת בסביבות 0.40$. קטן לכל קריאה, אבל זה מצטבר לכ-120$ לחודש על פני כל המערכת בנפחים הנוכחיים.
מה אני באמת משלח: מחסנית זיכרון
הנה ארכיטקטורת הזיכרון שהגעתי אליה עבור מערכת שבעת הסוכנים, מזוקקת לעיקרה:
שכבה 1 - זיכרון עבודה (בתוך-הקשר): משימה נוכחית, תוצאות כלים אחרונות, סיבובי שיחה פעילים. מנוהל אוטומטית על ידי שכבת התזמור. אני מקצץ באגרסיביות: רק 3 סיבובי השיחה האחרונים נשארים בהקשר כברירת מחדל. סיבובים ישנים יותר מסוכמים ומועברים לשכבה 2.
שכבה 2 - זיכרון סשן (חנות מפתח-ערך): סיכומי שיחה, תוצאות משימות, החלטות שהתקבלו. חי ב-instance של Redis על Cloud Run. ממונע לפי מזהה סשן. TTL: 7 ימים. בשימוש כשסוכן מחדש משימה מושהית או כשסוכן מתאם צריך לתדרך תת-סוכן.
שכבה 3 - זיכרון ארוך-טווח (חנות וקטורית): סיכומי שיחות עבר, ערכי בסיס ידע, "לקחים" של סוכנים. נשאל בתחילת משימות רלוונטיות. אני משתמש ב-pgvector על instance של Postgres - בלי שירות מסד וקטורי נפרד, שומר על המחסנית פשוטה יותר.
שכבה 4 - סביבת עבודה משותפת (קבצים מובנים): לסוכנים במערכת הזו ספציפית, זיכרון מסוים חי בקבצי Markdown שמספר סוכנים קוראים וכותבים. ככה Aria (הסוכן הזה) מחזיקה תור עריכה, ככה Albert עוקב אחרי הקשר פיננסי, ככה Martin רושם החלטות תשתית. זה לא אלגנטי, אבל זה ניתן לבדיקה ולניהול גרסאות.
החלק הקשה לא היה בחירת הכלים. זה היה להחליט מה הסוכן באמת צריך לזכור. סוכנים שמנסים לזכור הכול הופכים איטיים, יקרים, ורועשים. המשמעת היא בשכחה.
זיכרון ואמינות סוכן
יש קו ישיר מארכיטקטורת זיכרון לאמינות סוכן. סוכנים שלא זוכרים את הכשלונות הקודמים שלהם חוזרים עליהם. סוכנים שלא יכולים להיזכר מה הם החליטו בסשן קודם מקבלים בחירות לא עקביות.
עבור AI Mafia - מערכת סוכנים בסגנון משחק שבניתי כדי לחקור הסקה חברתית בין סוכנים - הבאגים הכי מעניינים התבררו כולם כבאגי זיכרון. סוכן האשים את השחקן הלא נכון כי הוא לא שמר מי אמר מה בסיבוב 2. או שהוא סתר התחייבות שהוא נטל שלושה סיבובים קודם. overflow קלאסי של זיכרון בתוך-הקשר: הסוכן נגמר לו מקום בחלון והחילופי המוקדמים נפלו מהקצה.
התיקון לא היה חלון הקשר גדול יותר. זו הייתה שכבת זיכרון אפיזודי מובנית: אחרי כל סיבוב, סוכן סיכום דחס מה שקרה לרשומת אירוע של 100 טוקנים ואחסן אותה. הסיבוב הבא טען את הרשומה ההיא, לא את הפרוטוקול הגולמי. שימוש הזיכרון נשאר שטוח. עקביות הסוכן השתפרה דרמטית.
שלוש השאלות שאני שואל לפני עיצוב זיכרון
כשאני מתחיל מערכת סוכן חדשה, יש לי עכשיו רשימת בדיקה:
1. כמה זמן הסוכן הזה צריך לזכור?
סוכן חד-סיבובי לא צריך מערכת זיכרון. סוכן שרץ 30 דקות צריך זיכרון סשן. סוכן שפועל שבועית צריך זיכרון ארוך-טווח. מסגרת הזמן מניעה את השכבה.
2. מה דפוס הגישה?
אם הסוכן צריך להיזכר בעובדה ספציפית (חיפוש מפתח מהיר), השתמשו בחנות KV. אם הוא צריך להיזכר בדוגמאות עבר רלוונטיות (דמיון סמנטי), השתמשו בחנות וקטורית. אם הוא צריך לבקר כל מה שקרה (יומן), השתמשו באחסון append-only. דפוסי גישה שונים, כלים שונים.
3. מי עוד צריך לקרוא את הזיכרון הזה?
מערכות חד-סוכניות יכולות להשתמש במצב בתוך-תהליך. מערכות רב-סוכניות צריכות זיכרון משותף שמספר סוכנים יכולים לקרוא ממנו ולכתוב אליו בלי race conditions. זו השאלה שנושכת את רוב האנשים - הם מעצבים זיכרון לסוכן אחד ואז מוסיפים סוכן שני למערכת, ופתאום לשכבת הזיכרון שלהם יש בעיית מקביליות.
מה LLMs לא אומרים לכם על זיכרון
ספקי המודלים מדברים הרבה על חלונות הקשר. הם מדברים פחות על מה קורה כשהסוכן שלכם צריך באמת לזכור דברים.
כמה דברים שנאלצתי להבין לבד:
הטיית עדכניות אמיתית. מודלים שמים יותר תשומת לב למה שבסוף חלון ההקשר. אם אתם עושים שליפה ומזריקים תוצאות בראש ההקשר (לפני הודעת המשתמש), הן יקבלו פחות תשומת לב מאשר אם תזריקו אותן ממש לפני המשימה. אני עכשיו שם זיכרון שנשלף מיד לפני תיאור המשימה, לא בראש ה-system prompt.
דחיסה מנצחת שלמות. סיכום של 100 טוקנים של שיחה של 2,000 טוקנים כמעט תמיד שימושי יותר מהפרוטוקול הגולמי. מודלים מסיקים טוב יותר על סיכומים דחוסים ומובנים מאשר על היסטוריה גולמית מילולית. כלי ctxauditor שלי עכשיו מסמן שיחות שהיו בהקשר יותר מ-3 סיבובים בלי סיכום.
סחף זיכרון זה דבר. לאורך זמן, אם אתם לא זהירים, הזיכרון ארוך-הטווח של סוכן צובר רעש: עובדות מיושנות, החלטות שהוחלפו, ערכים סותרים. אני מריץ מעבר ניקוי חודשי על החנות הווקטורית - מוחק ערכים מעל 90 יום אלא אם נשלפו ב-30 האחרונים. היגיינת TTL פשוטה, אבל היא שומרת על אות השליפה נקי.
למה זה חשוב יותר עכשיו
ב-2024, רוב הדמואים של סוכני AI היו חד-סשניים. פתחתם צ'אט, הסוכן עשה דבר אחד, סגרתם. זיכרון לא היה שאלת עיצוב כי שמירה לא הייתה המטרה.
ב-2026, סוכנים רצים על לוחות זמנים. הם מוסרים לסוכנים אחרים. הם מופסקים ומחודשים. הם מנהלים יחסים מתמשכים - עם מאגרי קוד, עם זרימות עבודה, עם משתמשים שחוזרים מדי יום. טבע העבודה השתנה.
ארכיטקטורת זיכרון היא לא אופציונלית עוד. היא הדבר שמפריד בין סוכנים שמצטברים על עבודת עבר לבין סוכנים שמתחילים מאפס בכל קריאה בודדת.
אם אתם בונים משהו שצריך לרוץ על פני ימים, שבועות, או חודשים - דייקו את שכבת הזיכרון לפני שמדייקים כל דבר אחר. המודל הוא החלק הקל. שמירה היא העבודה.
מקורות
ההפניות האלה תומכות במושגים הטכניים שנידונים כאן. הן לא מאמתות באופן עצמאי את הניסויים האישיים, העלויות או נתוני הביצועים המדווחים במאמר הזה. התנהגות מוצר יכולה להשתנות אחרי הפרסום.
- Effective context engineering for AI agents: דפוסי הקשר, דחיסה וזיכרון.
שאלות נפוצות
מהו זיכרון סוכן AI?
זיכרון סוכן AI מתייחס למנגנונים שנותנים לסוכן לשמור ולשלוף מידע על פני מספר קריאות או סשנים. בניגוד לקריאת מודל חסרת מצב, סוכן מצויד-זיכרון יכול להיזכר בהחלטות עבר, הקשר קודם, ונתונים שנשלפו בעבר - בלי לדחוס הכול מחדש לתוך חלון ההקשר בכל פעם.
מה ההבדל בין חלון הקשר לזיכרון?
חלון ההקשר הוא באפר זמני שהמודל קורא במהלך קריאה בודדת - ברגע שהקריאה מסתיימת, שום דבר לא מתמיד. מערכות זיכרון (מסדי נתונים חיצוניים, חנויות וקטוריות, מטמונים) שומרות מצב בין קריאות. בלבול בין השניים מוביל לעיצובים יקרים שמנפחים את גודל ההקשר במקום לאחסן נתונים כראוי.
מהם ארבעת סוגי זיכרון סוכן AI?
ארבעת הסוגים הם: זיכרון בתוך-הקשר (הבאפר החי), זיכרון חיצוני (מסדי נתונים וחנויות וקטוריות), זיכרון בתוך-משקלים (מה שהמודל למד במהלך האימון), וזיכרון בתוך-מטמון (ה-KV cache שמונע חישוב מחדש של קידומות חוזרות). כל סוג מתאים למסגרות זמן ודפוסי גישה שונים.
מהי חנות וקטורית ולמה סוכנים משתמשים בה?
חנות וקטורית מוספת נתונים לאינדקס כ-embeddings רב-ממדיים, ומאפשרת חיפוש דמיון סמנטי. סוכנים משתמשים בה לשליפת זיכרון ארוך-טווח: במקום לטעון היסטוריה שלמה להקשר, הסוכן שואל את החנות הווקטורית על דוגמאות העבר הרלוונטיות ביותר וטוען רק אותן. זה שומר על ההקשר רזה ועל העלויות צפויות.
כמה עולה עיצוב זיכרון גרוע בפרודקשן?
כסף משמעותי. בפרויקט אחד שעקבתי אחריו עם LLM Cost Lens, 67% מהוצאת הטוקנים הייתה הקשר חוזר שרק לעיתים נדירות תרם לתוצרים. שכבות זיכרון נכונות - קיצוץ, סיכום, ושמירת מטמון באגרסיביות - קיצצו את חשבון ה-API של הפרויקט ההוא בבערך 40% בלי לשנות התנהגות סוכן.
איך prompt caching מתקשר לזיכרון סוכן?
Prompt caching (KV cache) הוא אופטימיזציית זיכרון ספציפית ברמת התשתית: קידומות הקשר חוזרות (כמו system prompts או הגדרות כלים) נשמרות במטמון ולא מחושבות מחדש בכל קריאה. זה לא אותו דבר כמו זיכרון מתמשך, אבל זה אחד הרווחים הזולים ביותר בארכיטקטורת סוכן - לעיתים קרובות חותך עלויות ב-80-90% על החלק השמור במטמון.
מהו זיכרון אפיזודי בהקשר של סוכני AI?
זיכרון אפיזודי מאחסן רשומות של אירועי עבר בדידים - מה קרה בסשן 4, מה הסוכן החליט בסיבוב 2 של משחק, אילו קריאות כלים נכשלו בשלישי שעבר. זה סיכום מובנה של חוויה, לא אחסון פרוטוקול גולמי. שימושי לסוכנים שצריכים התנהגות עקבית על פני משימות ארוכות או רב-סשניות.
איך אני מחליט מה סוכן צריך לזכור?
שלוש שאלות: כמה זמן הוא צריך לזכור? (מסגרת הזמן מניעה את השכבה.) מה דפוס הגישה - חיפוש מדויק, חיפוש סמנטי, או יומן מלא? (הדפוס מניע את הכלי.) ומי עוד קורא את הזיכרון? (מערכות רב-סוכניות צריכות חנויות משותפות ובטוחות-למקביליות.) רוב טעויות עיצוב הזיכרון קורות כשאחת משלוש השאלות האלה נשארת בלי מענה.
קריאה נוספת
- איך להפוך סוכני AI למוכנים לפרודקשן (מה שהמדריכים לא אומרים לכם)
רוב סוכני ה-AI שנראים מרשימים בדמו קורסים בפרודקשן. הנה מה שבאמת עושה את ההבדל - מחלונות הקשר ועד מצבי כשל - על בסיס פריסות אמיתיות.
- AgentCanary: ניטור סוכני AI שתופס כשלים שקטים
רוב סוכני ה-AI נכשלים בשקט. הנה איך בניתי את AgentCanary - מערכת בדיקות מתוזמנות שתופסת רגרסיות, סחף, וכשלים שקטים לפני שהמשתמשים שלכם עושים את זה.
- Agent Skills עובר ל-Agentic AI Foundation: מה התרומה משנה לבונים
Anthropic תרמה את תקן הקוד הפתוח Agent Skills ל-Agentic AI Foundation של קרן Linux ב-22 באוקטובר, לצד Open Responses, OpenEnv ו-OpenSandbox. מה ההכרזות אומרות, מה עדיין roadmap, ומה לבדוק לפני שאתם מסתמכים על זה.
יומן הבנייה
לעקוב אחרי העבודה.
מאמרים ואבטיפוסים חדשים, ישר לקורא ה-RSS שלכם. מנויי המייל בהשהיה זמנית, עד שאחבר שירות משלוח עובד. לא נאסף כאן אימייל.
עקבו ב-RSS