SSD Nodes Learn 8GB RAM — $66/שנה
מדריכים Matt Connorמאת Matt Connor · עודכן 2026-08-01

Memmy: זיכרון מקומי משותף לסוכני AI ב-VPS

למדו כיצד לבנות את Memmy מקוד המקור ב-Ubuntu, להפעיל שירות זיכרון בפורט 18960 ולשמור את כל ההערות מקומית עבור Claude Code, Codex ו-Cursor.

מהו Memmy ומה הוא מאחסן

Memmy הוא מרכז זיכרון מקומי לסוכני AI, שפועל ב-VPS (שרת פרטי וירטואלי) שבבעלותכם. הוא שומר מסד נתונים יחיד של SQLite ובו הידע שהסוכנים שלכם צברו. כל סוכן בשרת קורא מאותו מאגר וכותב אליו. הפרויקט memmy-agent של MemTensor, מופץ ברישיון MIT, ובגרסה 1.0.4 נכון ליולי 2026.

רק חלק מהמערכת רלוונטי בשרת. Memmy כולל שירות זיכרון שמאזין ב-http://127.0.0.1:18960, ממשק שורת פקודה (CLI) מסוג memmy-memory שמתקשר עם השירות, וסביבת עבודה למחשבים שולחניים. סביבת העבודה מופצת רק עבור macOS ו-Windows. לכן ב-VPS מבוסס Linux מפעילים את השירות ואת ה-CLI. כך Claude Code, Codex ו-Cursor יכולים להשתמש בזיכרון משותף.

Memmy ממיין את התוכן שהוא מאחסן לארבע שכבות. L1 Trace הוא התיעוד הגולמי של התור: הבקשה, התגובה וקריאות הכלים. L2 Policy הוא נוהל שנגזר מתיעודים והוכח כשימושי. L3 World Model הוא ידע יציב על פרויקט או על סביבה. Skill הוא נוהל שניתן להפעיל, והתגבש ממדיניות. השירות מקצה שכבה בעת קליטת תור, ולכן אין ליצור את השכבות באופן ידני.

במה משתנה מרכז זיכרון משותף בהשוואה לזיכרון נפרד לכל כלי

כל סוכן כולל כיום מנגנון זיכרון משלו. Claude Code שומר קובצי הוראות במאגר. Cursor שומר כללים במסד הנתונים של סביבת העבודה שלו. Codex שומר יומני הפעלות תחת ~/.codex. כל מאגר שייך לכלי אחד, ולכן עובדה שלימדת ביום שני בכלי אחד אינה מוכרת ביום שלישי בכלי אחר. אתם משלמים על כך פעמיים: פעם אחת באסימונים שנדרשים להסביר מחדש את אותו פרויקט, ופעם נוספת בעבודה שגויה כאשר סוכן פועל לפי הנחה שכבר תיקנתם במקום אחר.

מרכז זיכרון מעביר את המאגר אל מחוץ לכלי. 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. אפשר להוסיף מקור באופן ידני באמצעות שם ונתיב מקומי.

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

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

מה נדרש ב-VPS

  • Node.js 22 ומעלה. תיעוד Memmy דורש זאת, ו-Ubuntu 24.04 מגיע עם Node 18.
  • git ושרשרת כלי בנייה, מכיוון ש-better-sqlite3 הוא מודול מקומי שעשוי לעבור הידור במהלך ההתקנה.
  • כ-2 GB של RAM. התקנת root מורידה סביבת עבודה גדולה ושרשרת כלי בנייה ל-frontend.
  • כמה GB של שטח דיסק פנוי עבור 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 --version

node --version צריך להציג את v22 ומעלה. ערך v18 כאן מציין ששלב NodeSource לא הושלם, ולכן ההתקנה תיכשל בהמשך בבדיקת המנוע של הפרויקט.

התקנת 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:build

npm run memory:build מהדר את סביבת העבודה @memmy/memory אל Memory/dist. אין צורך לבנות דבר נוסף בעץ הקבצים עבור שרת ללא ממשק גרפי. ודאו שהמודול המקורי נטען:

node -e "require('better-sqlite3'); console.log('better-sqlite3 loads')"

אם השורה הזו נכשלת במקום להדפיס פלט, המודול המקורי אינו תואם לגרסת Node שלכם. הריצו את npm rebuild better-sqlite3, בדיוק כפי שעושה סקריפט ההפעלה של הפרויקט לפני שהוא מפעיל דבר כלשהו.

ה-README מתעד את bash scripts/dev-start.sh כהפעלת פקודה יחידה. אל תריצו אותה ב-VPS ללא ממשק גרפי. היא מפעילה את מעטפת שולחן העבודה של Electron ואת שרת הפיתוח של Vite בפורט 19000 לצד שירות הזיכרון. Electron זקוק לתצוגה, ולכן בשרת ללא הפעלה גרפית הסקריפט נתקע או מסתיים.

הפעלת שירות הזיכרון ובדיקת המענה שלו

npm run memory:serve:dev

זו הדרך המתועדת להפעיל את שירות הזיכרון מקוד המקור. השירות מאזין ב-127.0.0.1:18960, שומר את מסד הנתונים ב-~/.memmy/memory-service/memory.sqlite וקורא את התצורה מ-~/.memmy/config.yaml. קובץ ה-README מציין את אותם ערכים במפורש:

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 הוא נקודת הקצה היחידה שאינה דורשת אסימון, ולכן הוא הבדיקה המתאימה. אם curl מסתיים בקוד 7 ומציג הודעת Failed to connect to 127.0.0.1 port 18960, שום תהליך אינו מאזין. קראו את הפלט במסוף שמריץ את השירות, מכיוון שקריסה בעת האתחול תופיע שם. הסיבה הנפוצה היא כשל בטעינת מודול SQLite המקורי. ss -lntp | grep 18960 מאשר שה-socket זמין לאחר שהשירות עלה.

שאר ה-HTTP API (ממשק תכנות היישומים) נמצא תחת /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 תוחמים סשן של סוכן.
  • POST /api/v1/turns/start ו-POST /api/v1/turns/:turnId/complete מתעדים תור אחד.
  • GET /api/v1/panel/overview, /api/v1/panel/analysis ו-/api/v1/panel/items מזינים את לוח המחוונים.

Memmy שומר בלוק של יציאות, ובמצב ללא ממשק גרפי משתמשים רק בראשונה: 18960 עבור הזיכרון, 18970 עבור תקינות ה-gateway, 18980 עבור ממשק המשתמש באינטרנט ו-HTTP הניהולי, 18990 עבור ה-API התואם ל-OpenAI ש-memmy serve מפעיל, ולאחר מכן 19000 ו-19010 עבור שרת הפיתוח של ממשק שולחן העבודה. אם תהליך כלשהו במחשב שלכם כבר משתמש באחת מהן, זו הרשימה שבה יש לבדוק.

מהיכן מגיעה בפועל הפקודה memmy-memory

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

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, מכיוון שתהליך הבנייה יוצר את dist ומסמן את הקובץ כקובץ הניתן להרצה. יש להריץ אותה ישירות:

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

ברירת המחדל של ממשק שורת הפקודה היא http://127.0.0.1:18960, והוא מקבל את --url, --token, --config, --source ו---user-id. פקודות המשנה שלו הן init, health, search, add, get ו-delete, וכן קריאות של session ושל turn שסוכנים משתמשים בהן, ולא משתמשים אנושיים. memmy-memory search "deploy steps" ו-memmy-memory add "staging migrates on deploy" הן שתי הפקודות שסוכן מריץ בתדירות הגבוהה ביותר.

כיצד מחברים את Claude Code ל-Memmy?

ל-Claude Code אין ממשק לתוספי זיכרון, ולכן Memmy אינו מתחבר אליו ישירות. האינטגרציה פשוטה יותר. Claude Code מריץ את memmy-memory כפקודת מעטפת רגילה, וקובץ הוראות מורה לו מתי לעשות זאת. תוכנית ההתקנה המתועדת של Memmy כותבת את הקובץ הזה עבורכם: memmy-memory init --agent מציב קובץ הוראות זיכרון בתיקיית הכללים של הסוכן היעד.

כתבו את ההוראה ידנית פעם אחת, כדי שתדעו בדיוק מה נאמר לסוכן. 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.

הגדירו בבירור מה האינטגרציה הזו מספקת. זהו שילוב ברמת ההוראות, ולכן הוא פועל רק כאשר המודל מחליט להריץ את הפקודה. דבר אינו כופה את ההפעלה. אם הפעלה מסתיימת בלי add, דבר לא נשמר, והסימן היחיד לכך הוא תוצאה ריקה בחיפוש הבא. זו אותה פשרה כמו קובצי הזיכרון של Claude Code עצמו, בהבדל אחד: מאגר הנתונים משותף, ולכן ההערה זמינה גם ל-Codex ול-Cursor באותו מחשב.

הכיוון ההפוך אינו דורש הגדרה כלל. הסורק של Memmy כבר קורא את ~/.claude/projects/**/*.jsonl, המקום שבו Claude Code כותב את תמלילי ההפעלות שלו. הריצו את Memmy באותו שרת שבו אתם מריצים את Claude Code בתוך הפעלת tmux, והעבודה מאתמול תהפוך לזיכרון בלי שתצטרכו להגדיר דבר.

האם Memmy פועל כשרת MCP עבור Claude Code?

לא. הבנת הכיוון הנכון חוסכת זמן. ל-MCP (פרוטוקול הקשר למודלים) יש לקוחות ושרתים. Memmy הוא לקוח. הוא מתחבר לשרתי MCP ומעמיד את הכלים שלהם לרשות סביבת הריצה של הסוכן שלו. הוא אינו מפרסם נקודת קצה של MCP שאליה claude mcp add יכול להתחבר. הגשר היחיד ל-MCP במאגר שייך לאינטגרציית Composio בתוך ה-API המקומי של שולחן העבודה. API זה מאזין ביציאה אקראית ב-127.0.0.1, מאחורי כותרת 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 מופעל כתהליך-בן של Memmy. לכן הפקודה שלו חייבת להיות זמינה באותו מחשב ולהופעל על ידי אותו משתמש. אם אתם כבר מפעילים שרתי MCP ב-VPS, אלה השרתים שיש לרשום כאן.

שמירה על מאגר הזיכרון פרטי

כל מה ש-Memmy מנהל נמצא תחת ~/.memmy: config.yaml, סביבת העבודה, memory-service/memory.sqlite וקובצי זמן הריצה. הסריקה והקליטה מתבצעות באופן מקומי, והזיכרונות נכתבים לקובץ SQLite המקומי. לכן, ברירת המחדל היא מקומית באמת.

שני נתיבים אכן מגיעים לרשת. MEMMY_CLOUD_SERVICE מוגדר כברירת מחדל ל-https://memmy-api.memtensor.cn ותומך במצב החשבון באמצעות אסימוני הניסיון שלו, ולכן מצב מפתח ה-API אינו קורא לו. תוכנית שיפור הזיכרון היא מתג נפרד בהגדרות הפרטיות. היא כבויה עד שמפעילים אותה.

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

השאר את פורט 18960 על כתובת ה-loopback. אין צורך בכלל חומת אש, משום ששירות הקשור ל-127.0.0.1 אינו נגיש מחוץ למחשב. גש אליו מהמחשב הנייד באמצעות SSH:

ssh -N -L 18960:127.0.0.1:18960 you@your-vps

אם אי-פעם תקשור אותו לכתובת רחבה יותר, הגדר תחילה אסימון. הגדרת storage.token בתצורה, או הגדרת משתנה הסביבה MEMMY_MEMORY_TOKEN או MEMORY_SERVICE_TOKEN, גורמת לכל נקודת קצה, למעט health, לדרוש אסימון bearer. ערכי תצורה תומכים בהפניות ${ENV_NAME}, ולכן האסימון ומפתחות ה-API של המודלים נשארים מחוץ לקובץ עצמו. זהו אותו נוהג של שמירת סודות מחוץ לסוכני AI בכל מקום אחר, ו-מדיניות ufw מסוג ברירת מחדל deny היא שכבת ההגנה שלך אם גרסה עתידית תשנה את כתובת הקשירה כברירת המחדל.

גבה את ~/.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 יעלה לך בכל הזיכרונות, ואין במחשב עותק נוסף שלהם.

הפעלת שירות הזיכרון באמצעות systemd

npm run memory:serve:dev במעטפת מסתיים יחד עם המעטפת. קובץ יחידה שומר על השירות פעיל גם לאחר אתחול.

[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

אין לשמור את האסימון ביחידה. יש לשמור אותו ב-/etc/memmy/memory.env, בבעלות root, עם הרשאות 600:

MEMMY_CONFIG=/home/memmy/.memmy/config.yaml
MEMMY_MEMORY_TOKEN=replace-this-with-a-long-random-string
sudo 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/health

status=203/EXEC בפלט המצב פירושו ש-systemd לא הצליח להפעיל כלל את ExecStart, לכן יש לבדוק את which npm: בהתקנת NodeSource זהו /usr/bin/npm, וב-nvm מדובר בנתיב מתחת לתיקיית הבית של המשתמש, ש-systemd לא ימצא. יחידה שמופעלת ומסתיימת מיד נכשלה בתוך npm, ו-journalctl -u memmy-memory -n 50 מציג את הסיבה. המנגנון זהה לזה של כל שירות systemd אחר ב-VPS.

מה Memmy עדיין אינו עושה

  • אין גרסת Linux למחשב שולחני. סקריפטי האריזה תומכים ב-macOS וב-Windows, ולכן סביבת העבודה, אשף ההגדרה הראשונית ולוח המחוונים של הזיכרון אינם זמינים בשרת עצמו.
  • memory:serve:dev מפעיל את נקודת הכניסה של TypeScript באמצעות tsx, שהוא נתיב פיתוח. המאגר כולל גם את memory:serve עבור פלט מקומפל. הפעילו את npm run ללא ארגומנטים כדי לראות אילו סקריפטים קיימים בפועל ב-checkout שלכם.
  • אחזור המידע בונה את חלון החיפוש מ-2,000 שורות הווקטורים האחרונות, ולאחר מכן מפעיל בחירה מסוג Top-K בתוך חלון זה. בחנות גדולה מאוד, זיכרון ישן עלול להימצא מחוץ לחלון.
  • יצירת ה-embedding מתבצעת לאחר הלכידה, וכשל נשלח לתור ניסיונות חוזרים במקום לחסום את תור הסוכן. ייתכן שזיכרון שנוסף לפני רגע עדיין לא יהיה ניתן לאיתור באמצעות חיפוש וקטורי.
  • קובץ SQLite יחיד פירושו node יחיד. אין clustering, ולכן שרת נוסף הוא זיכרון נפרד.

גרסה 1.0.4 וכ-329 כוכבים, נכון ליולי 2026, מעידים שמדובר בפרויקט צעיר. דגלים, נתיבים ושמות סקריפטים משתנים בין גרסאות. קראו את השדה bin ואת הפלט של npm run ב-checkout שלכם, במקום להסתמך על פקודה שהועתקה ממקום כלשהו, כולל מכאן.

FAQ

מדוע בדיקת התקינות מחזירה סירוב חיבור?

אף תהליך אינו מאזין ב-port 18960. קוד יציאה 7 של curl עם Failed to connect to 127.0.0.1 port 18960 מציין ששירות הזיכרון אינו פועל או שקרס בעת האתחול. קראו את הפלט במסוף או את ה-journal שבו השירות הופעל. שתי הסיבות הנפוצות הן מודול native מסוג better-sqlite3 שאינו תואם לגרסת Node, וגרסת Node הקודמת ל-22. מתקנים את הסיבה הראשונה באמצעות npm rebuild better-sqlite3. לאחר שהשירות פועל, אשרו את ה-socket באמצעות ss -lntp | grep 18960.

מה מקור הפקודה memmy-memory לאחר בנייה מקוד המקור?

הפקודה מגיעה מהשדה bin בחבילת סביבת העבודה @memmy/memory, ולא משם המאגר. הפעילו node -p "JSON.stringify(require('./Memory/package.json').bin)" בתוך עץ העבודה שהוצא, והוא ידפיס {"memmy-memory":"./dist/src/cli/index.js"}. הקובץ קיים רק לאחר npm run memory:build, מכיוון שתהליך הבנייה יוצר את dist ומסמן את הקובץ כניתן להרצה. הפעילו אותו באמצעות node Memory/dist/src/cli/index.js health, או צרו עבורו קישור סמלי בתוך /usr/local/bin כדי להשתמש בשם המקוצר.

האם אפשר להוסיף את Memmy ל-Claude Code באמצעות claude mcp add?

לא. Memmy הוא לקוח MCP, ולא שרת MCP. הוא מתחבר החוצה לשרתים הרשומים תחת tools.mcpServers בתוך ~/.memmy/config.yaml, ומציע את הכלים שלהם לסביבת ההרצה שלו. Claude Code ניגש אל Memmy בדרך אחרת: הוא מפעיל את ממשק שורת הפקודה memmy-memory כפקודת shell, לפי קובץ הוראות ש-memmy-memory init --agent כותב בספריית הכללים של הסוכן.

האם הפעלת Memmy שולחת את הזיכרונות שלי לשירות ענן?

הסריקה והקליטה מתבצעות באופן מקומי, והזיכרונות נכתבים אל ~/.memmy/memory-service/memory.sqlite בדיסק המקומי שלכם. MEMMY_CLOUD_SERVICE מפנה אל https://memmy-api.memtensor.cn עבור מצב חשבון ואסימוני ניסיון, ותוכנית שיפור הזיכרון נשארת מושבתת עד שתפעילו אותה. הרכיב שיש לנטר הוא ספק ה-embedding: מודל embedding מתארח מקבל את הטקסט של כל זיכרון שהוא ממיר לווקטור. לכן, אם הדבר חשוב לכם, השתמשו ב-endpoint שאתם מפעילים בעצמכם.

#memmy#memory#ai-agents#mcp#self-hosted