SSD Nodes Learn Hosting plans →
מדריכים Matt Connorמאת Matt Connor · עודכן 2026-10-25

Compartment: ניהול זיכרון מוצפן לסוכני AI באופן מקומי

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

מה Compartment עושה אחרת

Compartment הוא מאגר זיכרון לסוכנים, ששומר כל רשומה כשהיא מוצפנת במחשב שיצר אותה ואינו מתקשר עם שירות רשת. שתי בחירות מבדילות אותו משאר תחום זיכרון הסוכנים. הכספת היא קובץ חתום יחיד שנפתח רק באמצעות משפט הסיסמה שלך, ושלב יצירת ה־embedding פועל מקומית, כך שתוכן הזיכרון לעולם אינו נשלח לשום מקום לצורך המרתו לוקטור. גרסה 4.6.0 פורסמה ב־10 באוגוסט 2026, הרישיון הוא Apache-2.0, וההתקנה מתבצעת מ־PyPI. מאז יצאו גרסאות חדשות יותר, ונכון ל־12 באוקטובר 2026 הגרסה האחרונה ב־PyPI היא 4.11.0, מתאריך 30 בספטמבר 2026. מדריך זה נשאר מקובע לגרסה 4.6.0.

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

מדריך זה עוקב אחר התיעוד הרשמי של הפרויקט עבור גרסה 4.6.0, שנקרא מחדש לאחרונה ב־12 באוקטובר 2026. Compartment מספק יישום שולחני, פריט בשורת התפריטים ב־macOS וסמל באזור ההודעות ב־Windows, לצד כלי שורת הפקודה שלו, ואי־אפשר להפעיל בקשת משפט סיסמה מתוך container אוטומטי. התייחסו להמשך כאל התנהגות מתועדת, ולא כאל התנהגות שנמדדה כאן. הפעילו אותו במחשב חלופי לפני שתבטחו בו עם דבר־מה אמיתי.

מה באמת מגן הצפנה במנוחה (Encryption at Rest)

הכספת חתומה באמצעות XChaCha20-Poly1305, צופן AEAD (הצפנה מאומתת עם נתונים נלווים), ומשבצות המפתח (keyslots) המכילות את מפתח האב עטופות ב-Argon2id, פונקציית גיבוב סיסמאות שתוכננה להיות איטית ולצרוך זיכרון רב. מכאן נובעים שני דברים. עותק של הקובץ על דיסק גנוב, בגיבוי ישן או מצורף לכרטיס תמיכה הוא רצף בתים ותו לא. בנוסף, ביט אחד שהתהפך גורם לכישלון האימות בעת פתיחת הקובץ, כך ששחיתות נתונים הופכת לשגיאה גלויה במקום לתוצאה שגויה.

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

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

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

מה Compartment אינו מאבטח

ההגנה נעצרת בגבול ה-vault, וגבול זה קרוב יותר ממה שהוא נראה.

הסוכן קורא טקסט גלוי. תהליך ה-Recall מפענח זיכרון ומעביר את הטקסט לסוכן. אם הסוכן הוא מודל מאוחסן (hosted model), הזיכרון עובר לספק המודל בתוך ה-prompt הבא, בדיוק כמו כל דבר אחר בחלון ההקשר. הצפנה במנוחה (encryption at rest) מגנה על הקובץ, אך אינה מגנה על השליפה. לכן, הכללים ב-מניעת דליפת סודות לסוכני AI אינם משתנים גם כשהמאגר מוצפן: סיסמה שנשמרה כזיכרון היא סיסמה שהגדרת להדבקה אוטומטית בתוך prompt.

vault לא נעול במכונה פעילה הוא פרוץ. הערות האבטחה של הפרויקט מציינות זאת במפורש. בזמן שה-vault לא נעול, מפתח האב הראשי (master key) וקבוצת העבודה נמצאים ב-RAM. Python אינה יכולה להבטיח שחוצץ (buffer) ינוקה, וקובץ swap או תמונת hibernation עלולים לכתוב את הזיכרון הזה לדיסק. תוכנה זדונית שרצה תחת המשתמש שלך לעולם לא צריכה לפצח את הצופן, כיוון שהיא יכולה פשוט לבקש את המידע מה-vault שכבר פתוח.

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

גריסה (shredding) אינה מגיעה לעותקים. forget --shred משמיד את המפתח בתוך הקובץ הנוכחי. גיבוי שבוצע לפני הגריסה עדיין מכיל את הרשומה, ועדיין ניתן לפתיחה באמצעות סיסמת הגישה של אותו יום.

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

התקנת Compartment מגרסה מקובעת

Compartment דורש Python 3.11 ומעלה. הפרויקט מתקדם במהירות, עם 23 גרסאות שפורסמו ב־PyPI בין 26 ביולי ל־10 באוגוסט 2026, ו־35 גרסאות עד 12 באוקטובר 2026. לכן יש לקבע את הגרסה, במקום להתקין את הגרסה הזמינה ביום ההתקנה.

python3 --version
pip install "compartment==4.6.0"
compartment --version
compartment init

compartment --version אמור להציג את הגרסה שקיבעתם. אם ה־shell משיב compartment: command not found, ספריית ההתקנה אינה נמצאת ב־PATH שלכם, וברוב המערכות הספרייה הזו היא ~/.local/bin. pipx install compartment==4.6.0 ו־uv tool install compartment==4.6.0 מונעים זאת באמצעות ניהול נתיבי ההתקנה שלהם.

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

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

compartment status

כספת תקינה מדווחת שהיא פתוחה. אם היא מדווחת שהיא נעולה, הפעילו compartment unlock והזינו את משפט הסיסמה. הפעלה מחדש נועלת אותה שוב, משום שהאישור שמשאיר אותה פתוחה תלוי בסוד שנוצר בכל אתחול. ב־macOS, compartment unlock --keychain מאפשר לה לשמור על מצב פתוח לאחר אתחול מחדש, באמצעות שמירת האישור ב־keychain של המערכת.

היכן נשמר הנתונים בפועל

ה-vault המוגדר כברירת מחדל הוא ~/.compartment/memory.vault. ניתן להפנות למיקום אחר באמצעות --vault PATH בכל פקודה, או באמצעות משתנה הסביבה COMPARTMENT_VAULT.

קובץ יחיד זה מהווה את כלל המאגר. הוא נפתח בכותרת המכילה את גרסת הפורמט ואת ה-keyslots של Argon2id, לאחר מכן מגיע ה-payload המוצפן, ולבסוף רשומות יומן (journal entries) שמתווספות ככל שנוצרים זיכרונות חדשים. כל רשומת יומן מתוחמת על ידי האורך שלה ועל ידי CRC (בדיקת יתירות מחזורית) של אורך זה, כך שפעולת כתיבה שנקטעה עקב קריסה מזוהה כרשומה קטועה ולא נקראת כנתונים תקינים. תהליך הדחיסה (compaction) מבצע סריאליזציה ל-vault, כותב קובץ זמני, מבצע לו fsync, ולאחר מכן משנה את שמו למיקום הקובץ המקורי; המשמעות היא שקורא לעולם לא ייתקל ב-vault שנכתב בחלקו בלבד.

התוצאה המועילה: סקריפט גיבוי מעתיק נתיב אחד בלבד. התוצאה הלא נוחה: לא ניתן להריץ עליו grep, ולא ניתן לתקן אותו בעורך טקסט. אם ברצונכם בזיכרון שניתן לקרוא באמצעות cat ולבצע לו commit ל-git, ה-קבצי הזיכרון המקומיים הפשוטים של Memmy מציעים את הפשרה ההפוכה. שתי הגישות סבירות, בהתאם לשאלה האם האיום שממנו אתם חוששים הוא גניבת מחשב נייד או כלי עבודה שמתקלקל.

הפקודה compartment uninstall מסירה את התוכנה אך שומרת על ה-vault. השתמשו ב---purge רק כאשר אתם מתכוונים לכך במפורש.

חיבור לסוכן

פקודה אחת מחברת לקוח נתמך.

compartment integrate --list
compartment integrate claude

עבור Claude Code, הפקודה כותבת רכיב שרת MCP (פרוטוקול הקשר מודל) ו־hook מסוג PostToolUse לתוך ~/.claude/settings.json, תוך גיבוי הקובץ תחילה, מתקינה מיומנות /compartmentalize תחת ~/.claude/skills/, ומוסיפה בלוק מנוהל ל־~/.claude/CLAUDE.md המורה לסוכן ש-Compartment מחליף את הזיכרון מבוסס הקבצים שבו השתמש עד כה. יש לאשר את שני החלקים:

compartment hook status
compartment recent

כדי לרשום את השרת באופן ידני:

claude mcp add --scope user compartment -- \
    compartment --vault ~/.compartment/memory.vault --caller claude-code serve

כל מארח אחר התומך ב-MCP יכול להשתמש באותו שרת עם שם קורא משלו.

{ "mcpServers": { "compartment": {
    "command": "compartment",
    "args": ["--vault", "/path/to/memory.vault",
             "--caller", "your-agent-name", "serve"] } } }

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

אם Claude Code כבר כתב עובדות לקובצי הזיכרון שלו, compartment import-claude --dry-run יציג מה יועבר לפני ביצוע הפעולה. קראו תחילה את מה Claude Code שומר בקובצי הזיכרון שלו, כיוון שייבוא של הערות שנצברו במשך שנה לתוך כספת חדשה הוא הדרך שבה מאגר זיכרון מתמלא בפריטים שאף אחד לא התכוון לשמור.

מהי מהירותו של כספת מקומית

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

תרשיםCompartment published local latency, milliseconds
הנתונים שמאחורי התרשים
[
  {
    "label": "Store one memory, end to end",
    "latency_ms": 40
  },
  {
    "label": "Embed one memory, bundled model",
    "latency_ms": 25
  },
  {
    "label": "Hybrid search, median",
    "latency_ms": 11.6
  },
  {
    "label": "Vector search at 20k records, p95",
    "latency_ms": 0.68
  }
]

אחסון זיכרון אחד מוערך ב-40 מילי-שניות, וחיפוש וקטורי בקרב עשרים אלף רשומות מוערך ב-0.68 מילי-שניות עבור האחוזון ה-95. הטיעון של הפרויקט לשמירה על זיכרון מקומי הוא אריתמטי: סבב תקשורת רשת יחיד (round trip) ל-API של זיכרון מאוחסן עולה לעיתים קרובות יותר מהחציון של 11.6 מילי-שניות של חיפוש היברידי מלא כאן.

שני פרטי תכנון מסבירים את נתוני החיפוש. מתחת לעשרים אלף רשומות, Compartment משווה את השאילתה מול כל וקטור, כך שהשליפה מדויקת מעצם המבנה ולא מקורבת. מעל כמות זו, המערכת עוברת לשימוש ב-HNSW (hierarchical navigable small world), אינדקס מקורב שמקריב מעט דיוק בשליפה לטובת מהירות. הכספת גם מתעדת את ה-hash מסוג SHA-256 של מודל ה-embedding ומסרבת להיפתח תחת מודל שונה, כיוון שניתן להשוות וקטורים משני מודלים שונים ללא הופעת שגיאה, אך התוצאות שמתקבלות יהיו חסרות משמעות.

גיבויים, והעותק שתוכלו לפתוח גם בשנה הבאה

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

compartment lock
scp ~/.compartment/memory.vault other-machine:
compartment --vault memory.vault unlock

נעלו את הכספת תחילה. העתקה בזמן שהסוכן כותב עלולה לתפוס רשומה ביומן באמצע תהליך הוספה; אף ש־CRC framing מאפשר לקורא לדלג על אותו מקטע קטוע, הזיכרון שבתוכו אובד. compartment lock --sign חותם את הקובץ באמצעות manifest מסוג Ed25519, כך שהמכונה המקבלת יכולה לוודא שהעותק הגיע בשלמותו מבלי להחזיק בסיסמה.

מכיוון שהקובץ כבר חתום, אחסון ענן רגיל הוא יעד קביל עבורו. זו הנקודה שבה הצפנה במנוחה (encryption at rest) משתלמת ישירות: יעד הגיבוי לעולם אינו רואה את הזיכרון.

שתי אזהרות. פעולת Shredding אינה מגיעה לגיבויים; רשומה שהצפנתם בשיטת shred היום תישאר קריאה בעותק של השבוע שעבר לכל מי שמחזיק בסיסמה של השבוע שעבר. כמו כן, compartment export --plaintext כותב את כל הכספת ללא הצפנה; זהו הכלי הנכון למעבר למערכת אחרת, אך הקובץ הלא נכון להשאיר בתוך ~/Downloads.

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

ניהול מפתחות, החלפה (rotation) ואימות דו-שלבי

compartment rekey
compartment 2fa enable
compartment 2fa status

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

2fa enable מוסיף קובץ מפתח (keyfile) כגורם אימות שני, המשולב עם סיסמת הגישה במהלך גזירת המפתח, כך ששניהם נדרשים כדי לפתוח את הכספת. פעולה זו גם מכפילה את כמות הפריטים שניתן לאבד. שמרו את קובץ המפתח מחוץ למכונה שמחזיקה את הכספת.

עבור סקריפטים ו-CI (אינטגרציה רציפה), ניתן להעביר את סיסמת הגישה דרך משתנה הסביבה COMPARTMENT_PASSPHRASE, בעוד ש-unlock --passphrase-stdin קורא אותה מתוך צינור (pipe). העדיפו שימוש בצינור. משתנה סביבה הוא קריא על ידי תהליכים אחרים השייכים לאותו משתמש, והוא נוטה להופיע בלוגים של משימות.

היסטוריית הביקורת משורשרת באמצעות hash, ו-compartment audit verify סורק אותה ומדווח על הקישור השבור הראשון. הריצו פקודה זו לאחר כל שחזור, שכן זהו השלב שבו קובץ שנקטע בשקט חושף את עצמו.

מה קורה כשמאבדים את סיסמת הגישה

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

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

Compartment או שרת זיכרון

Compartment תוכנן לפעול במחשב יחיד. שיתוף בין מחשבים מחייב להעתיק את הקובץ הנעול, או לייצא ולייבא אותו. כמה סוכנים באותו מחשב יכולים להשתמש באותה כספת בו־זמנית, משום ש־file lock מייעץ מסדר את הכתיבות שלהם. התיעוד אינו מתאר דרך שבה שני מחשבים כותבים לאותו קובץ, ולכן אין להצביע ממחשב נייד ומתחנת עבודה אל אותה כספת דרך שיתוף רשת או תיקיית סנכרון.

כאשר כמה מחשבים זקוקים לאותו זיכרון באותו זמן, זו בעיה של שרת. שרת זיכרון Mem0 באירוח עצמי על VPS נותן לה מענה: נקודת קצה אחת, לקוחות רבים וזיכרון ששורד מעבר למחשב הנייד. חשוב לציין את המחיר במפורש. השרת מפעיל תהליך שיכול לקרוא את הנתונים שהוא שומר, ולכן מודל האיומים שלכם כולל כעת את ה־VPS ואת כל מי שיכול להגיע אל ה־API שלו.

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

FAQ

על מה ההצפנה של Compartment מגינה בפועל?

היא מגינה על הקובץ. הכספת חתומה באמצעות XChaCha20-Poly1305, חריצי המפתחות שלה עטופים באמצעות Argon2id, וגם וקטורי ה־embedding מוצפנים. לכן דיסק שנגנב או גיבוי ישן יניבו בתים שאין בהם דבר קריא. ההצפנה אינה מגינה על כספת פתוחה במחשב פועל, משום שהמפתח הראשי נמצא ב־RAM כל עוד הכספת פתוחה. היא גם אינה קובעת מה סוכן עושה עם זיכרון לאחר שה־recall מחזיר אותו כטקסט גלוי.

אם Compartment פועל ללא חיבור לרשת, האם הזיכרונות שלי פרטיים מספק המודל שלי?

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

מה קורה אם איבדתי את משפט הסיסמה של Compartment?

לא ניתן לשחזר את הכספת, בכוונה תחילה. Compartment אינו יוצר seed או משפט שחזור, ואינו מחזיק באישור שאינכם מחזיקים בו בעצמכם, ולכן אין דבר שאפשר לאפס. שמרו את משפט הסיסמה ב־password manager, שמרו כל קובץ מפתח של 2FA מחוץ למחשב שמאחסן את הכספת, ואשרו שאתם יכולים לפתוח עותק לפני שהכספת תכיל דבר־מה שיחסר לכם.

האם שני מחשבים יכולים לשתף כספת אחת של Compartment?

לא באותו זמן. כספת נעולה היא קובץ נייד יחיד, והדרך המתועדת היא לנעול אותה, להעתיק אותה, ולאחר מכן לפתוח אותה במחשב האחר באמצעות --vault. התיעוד מכסה את ה־file lock המייעץ שמסדר כתיבות רק עבור סוכנים באותו מחשב. הוא אינו מכסה מצב שבו שני מחשבים כותבים לאותו קובץ, ולכן יש להתייחס להגדרה כזו כאל דרך לאבד זיכרונות. הפעילו שרת זיכרון כאשר אתם זקוקים לכך.

האם המאמר הזה היה מועיל?

#agent-memory#compartment#encryption#offline#privacy