התקנת Memmy כמרכז זיכרון משותף לסוכני AI על שרת VPS
למדו כיצד להקים את Memmy על שרת Ubuntu כדי להעניק לסוכני AI כמו Claude Code ו-Cursor זיכרון משותף. הפעילו את השירות בפורט 18960 ונהלו את כל נתוני הסוכנים בבסיס SQLite מקומי.
מהו Memmy ומה הוא מאחסן
Memmy הוא מרכז זיכרון מקומי עבור סוכני AI, המופעל על גבי ה-VPS (שרת וירטואלי פרטי) שלכם. הוא מנהל מסד נתונים מסוג SQLite אחד שבו נשמר כל מה שהסוכנים שלכם למדו, וכל סוכן על השרת קורא וכותב לאותו מאגר. הפרויקט הוא memmy-agent מבית MemTensor, מופץ תחת רישיון MIT, ובגרסה 1.2.401 נכון ל-1 בנובמבר 2026; ה-Memory מתוחזק בגרסה נפרדת 2.1.7.
רק חלק מהרכיבים רלוונטיים לשרת. Memmy מפיץ שירות זיכרון המאזין ב-http://127.0.0.1:18960, ממשק שורת פקודה (CLI) מסוג memmy-memory המתקשר עם השירות, וסביבת עבודה שולחנית (workbench). סביבת העבודה ארוזה עבור macOS ו-Windows בלבד, לכן ב-Linux VPS עליכם להריץ את השירות ואת ה-CLI. זה מספיק כדי לספק ל-Claude Code, ל-Codex ול-Cursor זיכרון משותף.
Memmy ממיין את המידע שהוא מאחסן לארבע שכבות. שלב ה-Capture שומר תחילה Raw Turn נפרד, ולאחר מכן כותב פריט L1 Trace אחד עבור כל שלב שנתפס, כולל בקשות, תגובות, קריאות לכלים ותוצאות. L2 Policy הוא נוהל שנגזר מתוך עקבות (traces) שהוכחו כמועילים. L3 World Model הוא ידע יציב אודות פרויקט או סביבה. Skill הוא נוהל בר-קריאה שגובש מתוך מדיניות. ה-Capture יוצר עקבות L1, משימות רקע מפתחות את השכבות הגבוהות יותר, וכתיבה מפורשת יכולה לבחור שכבה ספציפית. אם ההבחנות הללו נראות מופשטות, הזיכרון הוא אחד השלבים המאוחרים ב-מסלול מדורג ללימוד בניית סוכנים, והשכבות הופכות למובנות יותר לאחר שתכתבו בעצמכם לולאת סוכן פשוטה ותצפו בו שוכח הכל בין הרצה להרצה.
מה משתנה בשימוש ב-shared memory hub לעומת זיכרון נפרד לכל כלי
כיום, כל סוכן (agent) מנהל זיכרון משלו. Claude Code שומר קובצי הנחיות בתוך ה-repository. Cursor שומר חוקים בתוך מסד הנתונים של ה-workspace. Codex שומר לוגים של סשנים תחת ~/.codex. כל מאגר שייך לכלי אחד בלבד, לכן עובדה שלימדת ביום שני בכלי אחד, אינה מוכרת ביום שלישי בכלי אחר. אתם משלמים על כך פעמיים: פעם אחת ב-tokens שמתבזבזים על הסבר חוזר של אותו פרויקט, ופעם שנייה בעבודה שגויה כאשר סוכן פועל על סמך הנחה שכבר תיקנתם במקום אחר.
מרכז זיכרון (hub) מוציא את האחסון מתוך הכלי. Memmy קורא גם את המאגרים הקיימים, כך שאינכם מתחילים ממסד נתונים ריק. הסורק שלו מכיר עשרה מקורות מובנים: Claude Code ב-~/.claude/projects/**/*.jsonl, Codex ב-~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl, OpenCode ב-~/.local/share/opencode/opencode.db, קובצי ה-state.vscdb של Cursor, מסדי הנתונים מסוג SQLite של OpenClaw תחת ~/.openclaw, Hermes תחת ~/.hermes, DeepSeek Harness תחת ~/.dsh/sessions, WorkBuddy תחת ~/.workbuddy/projects, Pi תחת ~/.pi/agent/sessions ו-QwenWork תחת ~/.qwenworkcn/projects. ה-desktop workbench מאפשר להוסיף סוכן נוסף לפי שם, ומבקש את נתיב ההיסטוריה שלו רק כאשר הוא אינו מצליח לאתר את הסוכן עצמו. הסורק בצד השרת אינו תומך במקורות מותאמים אישית, לכן ב-VPS ללא ממשק גרפי (headless) תקבלו את המקורות המובנים בלבד.
מוני הייבוא לא יהיו תואמים, וזה צפוי. הסורק מקבץ הודעות לפי מקור ושיחה, ולאחר מכן כותב זיכרון L1 אחד לכל תור (turn) שהושלם. תור נחשב למושלם כאשר יש בו תוכן משתמש שאינו ריק והוא מסתיים בהודעת עוזר שאינה ריקה; לכן, תור לא שלם אינו תורם דבר עד שסנכרון מאוחר יותר יוכל להשלים אותו. הודעות עוברות דה-דופליקציה (deduplication) באמצעות נקודות ביקורת של שיחה ומזהי תור יציבים. מספר הפריטים שנסרקו, מספר ההודעות שיובאו ומספר הזיכרונות החדשים יהיו שונים כולם באותה הרצה.
זהו החלק שמשתלב עם האופן שבו Claude Code מנהל הקשר בתוך סשן יחיד. ניהול הקשר קובע מה נכנס לחלון בודד. מרכז זיכרון קובע מה שורד לאחר שהחלון הזה נסגר.
מה נדרש בשרת ה-VPS
- Node.js בגרסה 22 ומעלה. התיעוד של Memmy מחייב זאת, בעוד ש-Ubuntu 24.04 מסופקת עם Node 18.
gitוכלי פיתוח (build toolchain), כיוון ש-better-sqlite3הוא מודול מקורי שעשוי לעבור הידור (compile) במהלך ההתקנה.- זיכרון RAM עבור התקנת סביבת העבודה הראשית (root workspace) ושרשרת ה-build של ה-frontend.
- שטח דיסק פנוי עבור
node_modulesומסד הנתונים.
sudo apt update
sudo apt install -y git build-essential python3 curl ca-certificates sqlite3
curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt install -y nodejs
node --versionnode --version אמור להציג v22 או גרסה גבוהה יותר עבור הידור המקור המתועד. v18 כאן מציין ששלב ה-NodeSource לא בוצע בהצלחה. הגדרת ה-engine-strict של npm היא כברירת מחדל false, לכן הצהרת מנוע לא תואמת בדרך כלל תפיק אזהרה במקום לגרום לכשל אוטומטי בהתקנה.
התקנת Memmy מקוד המקור ב-Ubuntu 24.04
git clone https://github.com/MemTensor/memmy-agent.git
cd memmy-agent
cp .env.example .env
npm install
npm run memory:buildnpm run memory:build מהדר את סביבת העבודה @memmy/memory לתוך Memory/dist. הוא גם בונה את AgentSourceCore, את מציג הזיכרון ואת רכיבי האינטגרציה הדרושים לסביבה זו. ודאו שהמודול המקורי (native module) נטען:
node -e "const Database = require('better-sqlite3'); const db = new Database(':memory:'); db.close(); console.log('better-sqlite3 loads')"אם השורה הזו מציגה שגיאה במקום פלט, קראו את השגיאה כדי לזהות כשל בטעינה או באתחול מסד הנתונים. במקרה של אי-התאמה במודול המקורי, הריצו את npm rebuild better-sqlite3, שזה בדיוק מה שסקריפט ההפעלה של הפרויקט מבצע לפני כל פעולה אחרת.
קובץ ה-README מתעד את bash scripts/dev-start.sh כפקודה אחת להפעלה. אל תריצו אותה על שרת VPS ללא ממשק גרפי (headless). הפקודה מפעילה את מעטפת ה-Desktop של Electron ואת שרת הפיתוח Vite בפורט 19000 לצד שירות הזיכרון; מאחר ש-Electron זקוק לתצוגה, הסקריפט ייתקע או ייסגר בשרת ללא סשן גרפי.
גרסאות אחרונות כוללות גם את memmy-agent-linux-cli.tar.gz ואת install.sh עבור Linux בגרסאות x64 ו-arm64. המתקין דורש Node.js בגרסאות 22.23.4 ומעלה (בתוך ענף 22.x), 24.22.1 ומעלה (בתוך ענף 24.x), או 26.12.1 ומעלה (בתוך ענף 26.x), בתוספת סשן משתמש ב-systemd; הוא דוחה גרסאות major אחרות. המתקין מציב את משגרי ה-memmy וה-memmy-memory ב-~/.local/bin, ומפעיל את שירות הזיכרון כיחידת משתמש ב-127.0.0.1:18960. מדריך זה שומר על בנייה מקוד המקור כיוון שזו הדרך שמאפשרת לכם לקרוא כל סקריפט לפני הרצתו.
הפעלת שירות הזיכרון ובדיקת תקינות המענה
npm run memory:serve:devזו הדרך המתועדת להרצת שירות הזיכרון מתוך קוד המקור. הוא מאזין ל-127.0.0.1:18960, שומר את מסד הנתונים ב-~/.memmy/memory-service/memory.sqlite, וקורא את התצורה מ-~/.memmy/config.yaml. השרת מקבל את אותם הערכים כדגלים (flags) כאשר ברצונך להגדירם במפורש:
npm run memory:serve:dev -- \
--host 127.0.0.1 --port 18960 \
--db ~/.memmy/memory-service/memory.sqlite \
--config ~/.memmy/config.yamlמתוך טרמינל שני, בדקו אם השירות פעיל:
curl -sS http://127.0.0.1:18960/api/v1/healthהבדיקה health אינה דורשת אסימון (token), ולכן היא הבדיקה המתאימה ביותר. אם הפקודה curl מסתיימת עם קוד יציאה 7 והודעת Failed to connect to 127.0.0.1 port 18960, החיבור נכשל; עובדה זו לבדה אינה מעידה אם קיים מאזין (listener). בדקו את הכתובת, הפורט וקיר האש המקומי, וקראו את הפלט בטרמינל שבו רץ השירות כדי לאתר שגיאות עלייה. ss -lntp | grep 18960 מאשר את קיום ה-socket ברגע שהשירות עלה.
שאר ה-API (ממשק תכנות יישומים) מבוסס HTTP נמצא תחת /api/v1.
POST /api/v1/memory/addכותב זיכרון ו-POST /api/v1/memory/searchמבצע שאילתה.GET /api/v1/memory/:idו-DELETE /api/v1/memory/:idקוראים ומסירים רשומה בודדת.POST /api/v1/sessions/openו-POST /api/v1/sessions/:sessionId/closeתוחמים סשן של סוכן (agent session).POST /api/v1/turns/startו-POST /api/v1/turns/:turnId/completeמתעדים תור (turn) אחד.GET /api/v1/panel/overview,/api/v1/panel/analysisו-/api/v1/panel/itemsמזינים את לוח הבקרה (dashboard).
Memmy משריין בלוק של פורטים, ובמצב ללא ממשק גרפי (headless) נעשה שימוש רק בראשון: 18960 עבור הזיכרון, 18970 עבור בדיקת תקינות ה-gateway, 18980 עבור ממשק ה-web והניהול ב-HTTP, 18990 עבור ה-API התואם ל-OpenAI ש-memmy serve מפעיל, לאחר מכן 19000 עבור שרת הפיתוח Vite של ה-frontend השולחני ו-19001 עבור ה-socket של ה-hot reload. דף הפורטים של הפרויקט עדיין מציין את 19010 עבור ה-hot reload, אך קובץ התצורה של Vite מגדיר את 19001. אם תהליך כלשהו במערכת שלכם כבר תופס אחד מהפורטים הללו, זה המקום לבדוק בו.
מקור הפקודה memmy-memory
כאן מתרחשות בדרך כלל תקלות בהתקנה הראשונית, לכן מומלץ לקרוא את המידע מהחבילה במקום לנחש. לשם הפקודה אין קשר לשם ה-repository. היא מגיעה מהשדה bin של ה-workspace המגדיר אותה:
node -p "JSON.stringify(require('./Memory/package.json').bin)"פעולה זו מדפיסה את {"memmy-memory":"./dist/src/cli/index.js"}. לכן, נקודת הכניסה שנבנתה היא Memory/dist/src/cli/index.js, והיא קיימת רק לאחר npm run memory:build, כיוון שה-build הוא זה שיוצר את dist ומסמן את הקובץ כניתן להרצה (executable). ניתן להריץ אותו ישירות:
node Memory/dist/src/cli/index.js healthאם ברצונכם להשתמש בשם הקצר ב-PATH שלכם, צרו קישור לאותו קובץ:
sudo ln -s "$PWD/Memory/dist/src/cli/index.js" /usr/local/bin/memmy-memory
memmy-memory healthה-CLI משתמש ב-http://127.0.0.1:18960 כברירת מחדל ומקבל את הדגלים --url, --token, --config, --source ו---user-id. פקודות המשנה שלו הן init, health, search, add, get ו-delete, בנוסף לקריאות session ו-turn שמשמשות סוכנים (agents) ולא בני אדם, וכן את install, upgrade, service ו-stop לניהול השירות עצמו. memmy-memory search "deploy steps" ו-memmy-memory add "staging migrates on deploy" הן שתי הפקודות שסוכן מריץ בתדירות הגבוהה ביותר.
כיצד מחברים את Claude Code ל-Memmy?
Memmy אינו רושם את עצמו כשרת בתוך Claude Code. הוא מתחבר דרך קבצים ש-Claude Code כבר קורא, והיקף הפעולה תלוי ב-memmy-memory שבו אתם משתמשים. מתוך עותק מקור (source checkout), ה-memmy-memory init --agent claude כותב Skill מסוג memmy-memory לתוך ~/.claude/skills/ ובלוק זיכרון מסומן לתוך ~/.claude/CLAUDE.md, ו-Claude Code מריץ את memmy-memory כפקודת shell רגילה כאשר ההוראות מורות לו לעשות זאת. המשגר (launcher) שמתקין ה-Linux מציב ב-~/.local/bin מרחיב את הפעולה: אותה פקודה רושמת גם hooks ב-~/.claude/settings.json עבור SessionStart, UserPromptSubmit, Stop, PostCompact ו-SessionEnd, אשר מזריקים זיכרון רלוונטי ושומרים כל תור (turn) שהושלם מבלי שהמודל יצטרך להחליט על כך.
כתבו את ההוראה ידנית פעם אחת, שכן כך תדעו בדיוק מה נאמר לסוכן. Claude Code קורא את CLAUDE.md משורש הפרויקט בתחילת כל סשן, לכן מקטע כזה מהווה את כל האינטגרציה בנתיב המקור:
## Memory
Before starting a task, run `memmy-memory search "<topic>"` and read what comes back.
When a task is done, run `memmy-memory add "<what you learned>"` for anything that will matter next session.היו ברורים לגבי התועלת בכך. ללא ה-hooks, מדובר באינטגרציה ברמת ההוראה, ולכן היא עובדת רק כאשר המודל מחליט להריץ את הפקודה, ולא אחרת. שום דבר לא כופה את הקריאה. אם סשן מסתיים ללא ה-add, ההוראה עצמה לא שמרה דבר; סריקת היסטוריה מאוחרת יותר עדיין יכולה לייבא את התור שהושלם. זהו אותו פשרה (trade-off) כמו ב-קבצי הזיכרון של Claude Code עצמו, עם הבדל אחד: המאגר משותף, כך שההערה מגיעה גם ל-Codex ול-Cursor באותו מחשב. ה-hooks סוגרים את הפער במקום לבקש יפה, וזו גם הסיבה שזיכרון עמיד (durable memory) נמצא לצד מגבלות תקציב וכללי הרשאות בין ה-תוספים של DeepSeek Harness שכדאי להתקין.
הכיוון השני אינו דורש הגדרה כלל. הסורק של Memmy כבר קורא את ~/.claude/projects/**/*.jsonl, המקום שבו Claude Code כותב את תמלילי הסשנים שלו. הריצו את Memmy על אותו שרת שבו אתם מריצים Claude Code בתוך סשן tmux והעבודה של אתמול הופכת לזיכרון מבלי שתצטרכו להגדיר דבר.
האם Memmy עובד כשרת MCP עבור Claude Code?
לא, והכרת הכיוון הנכון תחסוך לכם אחר צהריים שלם. ל־MCP (פרוטוקול הקשר למודלים) יש לקוחות ושרתים. Memmy הוא לקוח. הוא מתחבר לשרתי MCP ומציע את הכלים שלהם לסביבת ההרצה של הסוכן שלו. הוא אינו מפרסם נקודת קצה (endpoint) של MCP ש־claude mcp add יכול להצביע אליה. גשר ה־MCP היחיד במאגר שייך לאינטגרציה של Composio בתוך ה-API המקומי של שולחן העבודה, ו־API זה מאזין לפורט אקראי ב-127.0.0.1 מאחורי ה-header מסוג x-memmy-mcp-token.
צד הלקוח מוגדר ב-~/.memmy/config.yaml, הקובץ ש-MEMMY_CONFIG מצביע עליו, תחת tools.mcpServers:
tools:
mcpServers:
example:
type: stdio
command: npx
args:
- "-y"
- "your-mcp-server"
toolTimeout: 30
enabledTools:
- "*"type מקבל stdio, sse ו-streamableHttp. שרת stdio רץ כתהליך בן (child process) של Memmy, מה שאומר שהפקודה שלו חייבת להיות קיימת על אותו שרת ולרוץ תחת אותו משתמש. אם אתם כבר מחזיקים שרתי MCP רצים על VPS, אלו השרתים שיש לרשום כאן.
שמירה על פרטיות מאגר הזיכרון
כל מה ש־Memmy מחזיק נמצא תחת ~/.memmy: config.yaml, סביבת העבודה, memory-service/memory.sqlite וקבצי זמן הריצה. הסריקה והקליטה מתבצעות מקומית, והזיכרונות נכתבים לקובץ SQLite מקומי, כך שברירת המחדל היא פעולה מקומית בלבד.
החיבור לענן הוא נתיב אחד שיש להשגיח עליו. MEMMY_CLOUD_SERVICE מגדיר את מקור הענן. הקוד אינו מגדיר לו ערך ברירת מחדל, אך .env.example, ששלבי ההתקנה מעתיקים ל-.env, מגדיר אותו כ-https://api.memmy.cn. הוא מגבה את מצב החשבון עם אסימוני הניסיון שלו, ובכל פעם שהוא מוגדר, קוד הניתוח של Memmy שולח אליו אירועי שימוש, גם במצב API key: שמות אירועים ופקודות, גרסאות ומזהה התקנה. ה-CLI מדווח רק על מילות פקודה קבועות, לעולם לא על שאילתות חיפוש או טקסט של זיכרונות, וקוד הניתוח אינו שולח דבר כאשר הערך אינו מוגדר. לכן, בשרת שמשתמש רק ב-API keys, רוקנו את השורה הזו ב-.env לפני שתתחילו בכל פעולה. תוכנית שיפור הזיכרון היא מתג נפרד בהגדרות הפרטיות.
קריאות למודלים הן נתיב נוסף. אם תגדירו ספק הטמעות (embedding) מאוחסן, טקסט הזיכרון שעובר הטמעה יישלח לאותו ספק כדי להפוך לוקטור. אחסון מקומי אינו מסייע במקרה זה. השתמשו בספק ההטמעות המקומי המובנה או בנקודת קצה של הטמעות שאתם מארחים בעצמכם כדי לסגור נתיב זה. מודלים מאוחסנים של סיכום, אבולוציה וסינון רלוונטיות מקבלים גם הם תוכן זיכרון כאשר משימות אלו רצות, לכן בדקו גם את הגדרות המודלים הללו.
שמרו על פורט 18960 בכתובת ה-loopback. אין צורך בחוק firewall, כיוון ששירות שמאזין ל-127.0.0.1 אינו נגיש כלל מחוץ למכונה. גשו אליו מהמחשב הנייד שלכם באמצעות SSH:
ssh -N -L 18960:127.0.0.1:18960 you@your-vpsשירות הזיכרון הנוכחי דוחה כתובות האזנה שאינן loopback. הגדרת storage.token בקובץ התצורה, או משתני הסביבה MEMMY_MEMORY_TOKEN או MEMORY_SERVICE_TOKEN, מאבטחת קריאות API רגילות של זיכרון באמצעות bearer token; מצב הבריאות (health) נשאר ללא אימות, ומציג הדפדפן משתמש בבדיקות נפרדות לבקשות מקומיות. ערכי התצורה תומכים בהפניות ${ENV_NAME}, כך שהאסימון ומפתחות ה-API של המודלים שלכם נשארים מחוץ לקובץ עצמו. זהו אותו הרגל כמו ב-שמירה על סודות מחוץ לסוכני AI בכל מקום אחר, ו-מדיניות ufw של דחייה כברירת מחדל היא רשת הביטחון שלכם אם גרסה עתידית תשנה את כתובת ההאזנה המוגדרת כברירת מחדל.
בצעו גיבוי ל-~/.memmy לפני שתסתמכו עליו
memory.sqlite הוא המאגר המלא. הווקטורים נמצאים באותו קובץ דרך הסיומת sqlite-vec, לכן קובץ אחד מהווה את הגיבוי. העתקתו באמצעות cp בזמן שהשירות כותב אליו עלולה להוביל לבסיס נתונים פגום. השתמשו בפקודת הגיבוי המובנית של SQLite:
mkdir -p ~/memmy-backup
sqlite3 ~/.memmy/memory-service/memory.sqlite ".backup '$HOME/memmy-backup/memory.sqlite'"פעולה זו יוצרת עותק עקבי בזמן שהשירות ממשיך לרוץ. העבירו את הגיבוי מחוץ לשרת לפי לוח זמנים, וזהו בדיוק הייעוד של restic לאחסון מרוחק. אובדן של config.yaml יעלה לכם בהגדרות הספק שניתן להקליד מחדש. אובדן של memory.sqlite יעלה לכם בזיכרונות שתועדו מאז הגיבוי התקין האחרון; השירות אמנם יוצר גיבוי מקומי לפני ביצוע שינויי סכימה (schema migrations), אך זהו אינו עותק עדכני מחוץ לאתר.
הרצת שירות ה-memory תחת systemd
npm run memory:serve:dev בתוך shell מסתיים עם סגירת ה-shell. קובץ unit שומר על השירות פעיל לאחר אתחול. הוא רץ כמשתמש memmy, מתוך עותק ב-/opt/memmy, עם קובץ התצורה בתיקיית הבית של אותו משתמש. עצרו את העותק שרץ ב-shell שלכם, העבירו את העותק ואת התצורה, ועדכנו את הקישור memmy-memory:
sudo useradd -m -s /bin/bash memmy
sudo mkdir -p /opt/memmy
sudo mv ~/memmy-agent /opt/memmy/memmy-agent
sudo chown -R memmy:memmy /opt/memmy
sudo ln -sfn /opt/memmy/memmy-agent/Memory/dist/src/cli/index.js /usr/local/bin/memmy-memory
sudo install -d -o memmy -g memmy -m 700 /home/memmy/.memmy
sudo install -o memmy -g memmy -m 600 ~/.memmy/config.yaml /home/memmy/.memmy/config.yaml
sudo install -d -m 755 /etc/memmyהשירות שומר את מסד הנתונים שלו תחת /home/memmy/.memmy, לכן הוא מתחיל עם מאגר ריק.
[Unit]
Description=Memmy memory service
After=network-online.target
[Service]
Type=simple
User=memmy
WorkingDirectory=/opt/memmy/memmy-agent
EnvironmentFile=/etc/memmy/memory.env
ExecStart=/usr/bin/npm run memory:serve:dev
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.targetאל תכניסו את ה-token לתוך ה-unit. שמרו אותו ב-/etc/memmy/memory.env, בבעלות root, עם הרשאות 600:
MEMMY_CONFIG=/home/memmy/.memmy/config.yaml
MEMMY_MEMORY_TOKEN=replace-this-with-a-long-random-stringsudo systemctl daemon-reload
sudo systemctl enable --now memmy-memory
systemctl status memmy-memory --no-pager
curl -sS http://127.0.0.1:18960/api/v1/healthstatus=203/EXEC בפלט הסטטוס אומר ש-systemd לא הצליח להריץ את ExecStart כלל, לכן בדקו את which npm: זהו /usr/bin/npm בהתקנת NodeSource, או נתיב תחת תיקיית הבית של המשתמש ב-nvm, ש-systemd לא ימצא. יחידה שמתחילה ונסגרת מיד דורשת בדיקה של סטטוס היציאה וה-journal: קוד 0 הוא יציאה תקינה, בעוד תוצאות אחרות כוללות יציאות שאינן 0, אותות (signals) וזמני קצוב (timeouts). הריצו את journalctl -u memmy-memory -n 50 כדי לראות את הפלט של השירות. המנגנון זהה לכל שירות systemd אחר ב-VPS.
הפרויקט מציע כעת שתי חלופות ברמת המשתמש. הנתיב ב-README לבנייה ממקור הוא memmy-memory install --service-only, שמוריד את סביבת ה-runtime של Memory המקובעת ורושם שירות משתמש, ומתקין ה-Linux מגדיר את memmy-memory.service כיחידת systemd --user. אף אחד מהם לא מפעיל linger, לכן הריצו את sudo loginctl enable-linger <user> כדי לשמור על מנהל השירותים של המשתמש פעיל לאחר התנתקות (logout) ולהפעיל אותו בעת עליית המערכת.
מה Memmy עדיין לא עושה
- לא קיימת גרסה לשולחן עבודה עבור Linux. סקריפטי האריזה תומכים ב-macOS וב-Windows בלבד, לכן ה-workbench ואשף ההגדרה הראשונית אינם זמינים על השרת עצמו. שירות הזיכרון כולל כעת מציג דפדפן ב-
http://127.0.0.1:18960/viewer/, אליו ניתן לגשת דרך מנהרת ה-SSH שהוגדרה לעיל. עבור Linux מסופק קובץ tarball עם CLI ו-install.shבמקום זאת. memory:serve:devמריץ את נקודת הכניסה של TypeScript דרךtsx, נתיב המיועד לפיתוח. המאגר מספק גם אתmemory:serveעבור פלט שעבר הידור. הריצו אתnpm runללא ארגומנטים כדי לראות אילו סקריפטים קיימים בפועל בגרסה שברשותכם.- תהליך השליפה בונה את חלון החיפוש מתוך 2,000 שורות הווקטור האחרונות, ולאחר מכן מבצע בחירת Top-K בתוך חלון זה. במאגר גדול מאוד, זיכרון ישן עלול להישאר מחוץ לטווח זה.
- יצירת ה-embedding מתבצעת לאחר הלכידה, וכשל בתהליך מועבר לתור ניסיונות חוזרים במקום לחסום את פעולת ה-agent. זיכרון שנוסף לפני רגע עשוי שלא להיות זמין עדיין לחיפוש וקטורי.
- לשרת שני בעל מסד נתונים SQLite מקומי משלו יש זיכרון נפרד.
גרסה 1.2.401 נכון ל-1 בנובמבר 2026 מתארת פרויקט צעיר שמתפתח במהירות. דגלים (flags), נתיבים ושמות סקריפטים משתנים בין גרסאות. קראו את השדה bin ואת הפלט של npm run בגרסה המקומית שלכם, במקום להסתמך על פקודה שהועתקה ממקור כלשהו, כולל מכאן.
FAQ
מדוע בדיקת התקינות (health check) מחזירה connection refused?
קוד יציאה 7 של curl עם Failed to connect to 127.0.0.1 port 18960 מעיד על כשל בחיבור, אך לא על כך ש-Memmy נעצר, קרס, מאזין בפורט אחר או אינו נגיש. בדקו את הכתובת והפורט, הריצו את ss -lntp | grep 18960, ועיינו בטרמינל או ביומן (journal) שבו השירות הופעל. אם הלוג מדווח על אי-התאמה במודול SQLite מקומי, הריצו את npm rebuild better-sqlite3. בדקו גם את גרסת ה-Node שלכם: התיעוד של קוד המקור דורש Node 22 ומעלה, בעוד מתקין ה-Linux מקבל רק Node.js 22.23.4 ומעלה בתוך סדרת 22.x, 24.22.1 ומעלה בתוך 24.x, או 26.12.1 ומעלה בתוך 26.x.
מאיפה מגיע הפקודה memmy-memory לאחר בנייה מקוד המקור?
היא מגיעה משדה ה-bin של חבילת ה-workspace בשם @memmy/memory, ולא משם המאגר (repository). הריצו את node -p "JSON.stringify(require('./Memory/package.json').bin)" בתוך תיקיית ה-checkout והיא תדפיס את {"memmy-memory":"./dist/src/cli/index.js"}. קובץ זה קיים רק לאחר npm run memory:build, כיוון שהבנייה יוצרת את dist ומסמנת את הקובץ כניתן להרצה. הריצו אותו בתור node Memory/dist/src/cli/index.js health, או צרו קישור סימבולי (symlink) אליו בתוך /usr/local/bin כדי להשתמש בשם הקצר.
האם ניתן להוסיף את Memmy ל-Claude Code באמצעות claude mcp add?
לא. Memmy הוא לקוח MCP, לא שרת MCP. הוא מתחבר לשרתים המפורטים תחת tools.mcpServers בתוך ~/.memmy/config.yaml ומציע את הכלים שלהם לסביבת הריצה שלו. Claude Code ניגש ל-Memmy בכיוון ההפוך, על ידי הרצת ה-CLI בשם memmy-memory כפקודת shell. הקובץ memmy-memory init --agent claude כותב Skill ובלוק CLAUDE.md שמנחים אותו מתי לפעול, והמפעיל (launcher) ממתקין ה-Linux מוסיף גם hooks של Claude Code ששומרים תורות (turns) באופן אוטומטי.
האם הרצת Memmy שולחת את הזיכרונות שלי לשירות ענן?
סריקה וקליטת נתונים מתבצעות מקומית, והזיכרונות נכתבים ל-~/.memmy/memory-service/memory.sqlite על הדיסק שלכם. MEMMY_CLOUD_SERVICE, המוגדר כ-https://api.memmy.cn בתוך .env.example, משרת את מצב החשבון ואסימוני ניסיון (trial tokens) ומקבל נתוני אנליטיקה על השימוש ללא טקסט הזיכרונות כל עוד הוא מוגדר; רוקנו אותו אם אתם משתמשים רק במפתחות API. לתוכנית שיפור הזיכרון יש מתג פרטיות נפרד. מודל הטמעה (embedding model) מאוחסן מקבל את טקסט הזיכרון שהוא הופך לוקטור; השתמשו בספק המקומי המובנה או ב-endpoint שאתם מריצים בעצמכם כדי לשמור על עיבוד זה מקומי. מודלים מאוחסנים של סיכום, אבולוציה וסינון רלוונטיות מקבלים גם הם את תוכן הזיכרון כאשר משימות אלו רצות.