זיכרון לסוכני AI: ארבעה סוגים ואיך לשמור אותם

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

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

למה חלון הקשר אינו זיכרון

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

זיכרון הוא השכבה שמחליטה מה ייכנס לחלון בהמשך. היא שומרת את התורות האחרונים ומוצאת את העובדות הישנות המעטות שחשובות. היא מחזיקה את מצב המשימה הנוכחית ורושמת מה הסוכן עשה. גם חוקרים מתארים סוכנים במונחים דומים. מסגרת CoALA מאת Sumers, Yao, Narasimhan ו-Griffiths מפרידה בין זיכרון עבודה לבין זיכרון לטווח ארוך אפיזודי, סמנטי ופרוצדורלי.

ארבעת סוגי הזיכרון לסוכני AI

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

זיכרון שיחה

זהו התמליל לטווח קצר של סשן אחד. להודעות יש תפקיד (system, user, assistant או tool). הן יושבות בחלון נע מוגבל, כך שהתורות הוותיקים ביותר נושרים כשמגיעים למגבלה. הוא עונה על שאלה אחת. מה נאמר לאחרונה? ב-HotKV אלה AMEM.CONV.CREATE, AMEM.CONV.APPEND ו-AMEM.CONV.WINDOW.

זיכרון סמנטי

זיכרון סמנטי הוא ידע לטווח ארוך שנשמר כעובדות עם וקטור embedding. הסוכן שולף אותן לפי משמעות ולא לפי מפתח. מאחוריו עומד אינדקס וקטורי HNSW, מאותו סוג שמפעיל את החיפוש הווקטורי. AMEM.SEM.STORE שומר עובדה ו-AMEM.SEM.RECALL מחזיר את ההתאמות המובילות עם ציון דמיון. כאן שייכים מסמכים, העדפות משתמשים ותיקונים שנלמדו.

זיכרון עבודה

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

זיכרון אפיזודי

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

זיכרון לסוכני AI בפועל

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

שמירת זיכרון באמצעות פקודות

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

AMEM.CONV.CREATE session-42 WINDOW 50 TTL 86400
AMEM.CONV.APPEND session-42 user "My invoice shows the wrong VAT number."
AMEM.WORK.SET session-42 ticket "INV-1932" TTL 3600
AMEM.EPIS.LOG agent-support action "Looked up invoice INV-1932"

AMEM.SEM.CREATE support-kb 3
AMEM.SEM.STORE support-kb vat-policy "VAT details can be corrected within 30 days." 0.1 0.2 0.3
AMEM.SEM.RECALL support-kb 3 0.1 0.2 0.3
AMEM.CONV.WINDOW session-42 10

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

קריאת הזיכרון בכל תור

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

import hotkv

r = hotkv.from_url("hotkv://localhost:6379")
MIN_SIMILARITY = 0.8          # tune on your own data

def start_session(session: str) -> None:
    r.amem_conv_create(session, window=50, ttl=86400)   # create once, before the first append

def build_context(session: str, question: str) -> str:
    r.amem_conv_append(session, "user", question)
    turns = r.amem_conv_window(session, 10)
    facts = r.amem_sem_recall("support-kb", 3, embed(question))
    facts = [f for f in facts if f["similarity"] >= MIN_SIMILARITY]
    ticket = r.amem_work_get(session, "ticket")
    return render(turns, facts, ticket)      # your prompt template

def finish_turn(session: str, agent: str, reply: str) -> None:
    r.amem_conv_append(session, "assistant", reply)
    r.amem_epis_log(agent, "action", "Answered a billing question")
    r.amem_work_set(session, "last_step", "answered")

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

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

סיכומים במקום חלונות ארוכים יותר ויותר

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

HotKV שומר סיכום אחד לכל סוכן עם AMEM.SUMMARY.SET, AMEM.SUMMARY.APPEND ו-AMEM.SUMMARY.GET. SET מחליף את הטקסט ו-APPEND מוסיף שורה. כל עדכון מעלה מספר גרסה, כך שרכיב אחר יכול לדעת בזול שהסיכום השתנה ומתי.

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

כללי תכנון ושמירה

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

כללים ששומרים על זיכרון שימושי

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

כמה זמן לשמור כל סוג

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

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

איך זיכרון סוכנים משתבש

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

כשלים נפוצים

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

מתייחסים לטקסט שמור כאל לא אמין

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

מה מדדנו ומה לא

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

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

שימוש בזיכרון סוכנים מ-Claude Code או מ-Cursor

עוזר שתומך ב-Model Context Protocol יכול להשתמש בחלק מהזיכרון הזה בלי קוד מותאם. שרת הקוד הפתוח hotkv-mcp חושף זיכרון שיחה, הערות עבודה, יומן אירועים וסיכום נע ככלים. יש לו מצב קריאה בלבד ומרחב שמות שמגביל את הסוכן. הוא אינו חושף זיכרון סמנטי, והכלים שלו לא יכולים לקבוע חלון או זמן חיים, ולכן לאלה משתמשים בספריית הלקוח. המאמר הבא, שרת MCP לזיכרון סוכנים, מראה איך לחבר אותו ומה אמצעי ההגנה שלו מכסים.

שאלות נפוצות