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

אירוח עצמי של mem0 על VPS: מדריך התקנה ודרישות RAM

למדו איך להריץ mem0 על שרת VPS עם Docker Compose. המדריך מפרט את צריכת ה-RAM האמיתית, הגדרת TLS ל-API, קישור ל-localhost ושימוש ב-Ollama לאחסון זיכרון מקומי מלא.

מה העלות האמיתית ב-RAM של אירוח עצמי ל-mem0 על גבי VPS

אירוח עצמי של mem0 מחייב הרצה של שלושה קונטיינרים: שרת ה-FastAPI לניהול זיכרון, מסד הנתונים Postgres עם התוסף pgvector, ולוח בקרה מבוסס Next.js. mem0 הוא שכבת זיכרון עבור סוכנים (agents). אתם שולחים אליו שיחה, מודל שפה מחלץ ממנה עובדות קבועות, והעובדות הללו נשמרות כווקטורים כדי ששאילתה עתידית תוכל לשלוף את הרלוונטיות שבהן.

הערכת הגודל בפוסט זה מתאריך 2026-10-25 עמדה על כ-1 GB זיכרון עבור שלושת הקונטיינרים, ו-3 עד 4 GB שטח דיסק לאחר בניית האימג'ים. ההמלצה הייתה על VPS עם 2 GB זיכרון כאשר מודל השפה מתארח במקום אחר. עבור מודל 8B שעבר קוונטיזציה ל-4 ביטים ורץ על אותו שרת באמצעות Ollama, ההערכה הייתה כ-6 GB עבור המודל בלבד, ו-8 GB עבור התקנה מקומית מלאה.

אל תסתמכו על הנתונים הללו מפוסט בבלוג, כולל זה. מדדו את ה-stack שבניתם בפועל.

docker compose ps
docker stats --no-stream
docker system df -v

docker stats מציג את צריכת הזיכרון לכל קונטיינר, תוך הפחתת השימוש ב-cache בלינוקס. docker system df -v מציג את שטח הדיסק שתופס כל אימג' וכל volume.

מצב עבודה יציב אינו מצב השיא. docker compose up -d --build מבצע קומפילציה ללוח הבקרה של Next.js, ותהליך הבנייה של Node הוא הרגע התובעני ביותר בכל ההתקנה. אם הבנייה מסתיימת עם exit code 137, בדקו אם התרחש out-of-memory kill. אשרו את הסיבה לפני שאתם מחפשים באג ב-Docker:

dmesg -T | grep -i "killed process"

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

האם אני זקוק ל-Neo4j עבור זיכרון גרף ב-mem0?

לא. אם מדריך כלשהו מנחה אותך להוסיף קונטיינר של Neo4j, המדריך הזה ישן יותר מהקוד.

זיכרון גרף ב-mem0 התבסס בעבר על מסד נתונים חיצוני לגרפים, שהוגדר תחת מפתח graph_store כאשר enable_graph מוגדר כ-true. אלגוריתם הזיכרון החדש, ששוחרר באפריל 2026, הסיר את שני המפתחות הללו מ-SDK הקוד הפתוח. חילוץ ישויות מתבצע כעת בתוך נתיב ה-add הרגיל, והישויות נכתבות לאוסף pgvector שני שנקרא על שם האוסף הראשי שלך בתוספת הסיומת _entities. אין צורך בשלב הגדרה: האוסף נוצר בשימוש הראשון, כך שקישור ישויות מובנה מתחיל לעבוד בקריאת ה-add הבאה.

הוויתור על מאגר הגרפים חוסך קונטיינר JVM, את ה-heap שלו, ומאות מגה-בייטים של image. בשרת VPS עם 2 GB זיכרון, זהו ההבדל בין הרצה תקינה לבין כניסה ל-swapping.

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

קובץ ה-compose במאגר מיועד לפיתוח

server/docker-compose.yaml מצהיר על name: mem0-dev, וזו כוונתו. קראו אותו לפני ההרצה, כיוון שחמישה דברים בו אינם מתאימים לשרת.

  • הוא מבצע build מתוך server/dev.Dockerfile ומבצע mount לתיקיית העבודה שלכם על גבי ה-image באמצעות .:/app, כך שה-container מריץ את מה שנמצא בתיקייה זו במקום את מה שבניתם.
  • הפקודה שלו היא rm -rf /app/packages && pip install -q --force-reinstall --no-deps mem0ai && alembic upgrade head && uvicorn main:app --host 0.0.0.0 --port 8000 --reload. היא מתקינה מחדש את mem0ai מ-PyPI בכל הפעלה, כך שהגרסה שהשרת מריץ עלולה להשתנות במהלך restart שלא התכוונתם שיהיה שדרוג.
  • אותו שלב של pip אומר ש-restart ללא גישה לרשת החיצונית ייכשל לפני ש-uvicorn יספיק לעלות. שרת הזיכרון שלכם יושבת כיוון ש-PyPI לא היה זמין.
  • --reload מפעיל את מנגנון המעקב אחר קבצים של uvicorn. הוא קיים כדי להפעיל מחדש את התהליך כשאתם עורכים קוד, והוא צורך זיכרון ותהליך נוסף ללא כל תועלת בסביבת production. ה-Dockerfile של ה-production נושא גם הוא את --reload בתוך ה-CMD שלו, כך שאתם דורסים את הפקודה בכל מקרה.
  • הפורטים המפורסמים הם "8888:8000", "8432:5432" ו-"3000:3000". פורט שמפורסם ללא כתובת מוגדרת לפניו מאזין ל-0.0.0.0, כך ש-Postgres עונה לאינטרנט הציבורי בפורט 8432 ברגע שה-stack עולה.

הנקודה האחרונה הזו ראויה לאזהרה משל עצמה. Docker מפרסם פורט על ידי כתיבת חוקים משלו לפני ה-chain ש-ufw מנהל, לכן ufw deny 8432 לא חוסם פורט של container שפורסם. המדריך פרסום פורטים ב-Docker עוקף את ufw מפרט את החוקים המעורבים בכך.

קובץ compose עבור שרת אמיתי

עבדו בתוך server/, שמרו על init-db.sh במקומו, והחליפו את docker-compose.yaml בתוכן הבא.

name: mem0

services:
  mem0:
    build:
      context: .
      dockerfile: Dockerfile
    restart: unless-stopped
    env_file: .env
    ports:
      - "127.0.0.1:8888:8000"
    networks: [mem0_network]
    volumes:
      - mem0_history:/app/history
    depends_on:
      postgres:
        condition: service_healthy
    command: >
      sh -c "alembic upgrade head &&
             uvicorn main:app --host 0.0.0.0 --port 8000"
    environment:
      - PYTHONUNBUFFERED=1
      - DASHBOARD_URL=https://mem0.example.com
      - APP_DB_NAME=mem0_app
      - AUTH_DISABLED=false
      - MEM0_TELEMETRY=false

  postgres:
    image: pgvector/pgvector:pg17
    restart: unless-stopped
    shm_size: "128mb"
    networks: [mem0_network]
    environment:
      - POSTGRES_USER=${POSTGRES_USER:-postgres}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env}
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -q -U ${POSTGRES_USER:-postgres}"]
      interval: 5s
      timeout: 5s
      retries: 5
    volumes:
      - postgres_db:/var/lib/postgresql/data
      - ./init-db.sh:/docker-entrypoint-initdb.d/init-db.sh

  mem0-dashboard:
    build: ./dashboard
    restart: unless-stopped
    ports:
      - "127.0.0.1:3000:3000"
    networks: [mem0_network]
    environment:
      - NEXT_PUBLIC_API_URL=https://mem0.example.com
      - API_INTERNAL_URL=http://mem0:8000
    depends_on:
      mem0:
        condition: service_started

volumes:
  postgres_db:
  mem0_history:

networks:
  mem0_network:
    driver: bridge

חמישה שינויים הם בעלי חשיבות כאן, ולכל אחד מהם יש סיבה.

כל ערך ports מתחיל ב־127.0.0.1, כך שהליבה (kernel) מקבלת חיבורים אלו רק מהשרת עצמו. כל תעבורה מבחוץ מגיעה דרך ה־reverse proxy, שהוא הרכיב היחיד שמחזיק בתעודה.

ל־Postgres אין בלוק ports כלל. המכולה של mem0 מגיעה אליו דרך mem0_network באמצעות שם השירות, לכן פרסום פורט 8432 אינו מועיל ועולה בפורט פתוח מיותר. השתמשו ב־docker compose exec postgres psql -U postgres כאשר אתם זקוקים ל־shell.

ההיסטוריה עוברת מ־bind mount בנתיב ./history ל־named volume. בעוד ש־bind mount קושר את הנתונים לנתיב ספציפי ול־uid מסוים במארח, named volume הוא אובייקט ש־Docker יכול לבצע לו snapshot ולהעביר. המאמר Named volumes against bind mounts מפרט מתי נכון להשתמש בכל אחד מהם.

הפקודה מסירה את --reload ושומרת על alembic upgrade head. הקפידו על שלב ה־migration הזה. בלעדיו, היישום יעלה מול מסד נתונים ללא טבלאות, וכל בקשה תיכשל בשאילתה הראשונה.

הערך NEXT_PUBLIC_API_URL הוא ה־URL שהדפדפן שלכם פונה אליו, לכן הוא חייב להיות כתובת ה־HTTPS הציבורית ולא http://mem0:8000. רכיב Next.js מטמיע ערכי NEXT_PUBLIC_ בזמן ה־build, אך ה־image של לוח הבקרה הזה מכיל מציין מיקום (placeholder), ונקודת הכניסה (entrypoint) מחליפה אותו בערך האמיתי בעת עליית המכולה. לכן, שינוי הערך מחייב docker compose up -d mem0-dashboard, שמבצע יצירה מחדש של המכולה, ולא בנייה מחדש. פקודת docker compose restart mem0-dashboard עושה שימוש חוזר במכולה הישנה, שהקבצים שלה כבר מכילים את הערך הישן, ולוח הבקרה ימשיך לפנות לכתובת השגויה.

סודות נשמרים בתוך .env, וקובץ .env נשאר מחוץ לאינטרנט

cd server
cp .env.example .env
openssl rand -hex 32    # paste into JWT_SECRET
openssl rand -hex 32    # paste into ADMIN_API_KEY
chmod 600 .env

הגדירו את POSTGRES_PASSWORD, JWT_SECRET ו-ADMIN_API_KEY. הותירו את AUTH_DISABLED=false כפי שהוא. השם של הדגל מעיד במדויק על תפקידו: כאשר הוא פעיל, השרת חושף את כל הזיכרון שברשותו לכל מי שיכול להגיע לפורט. הגדירו את MEM0_TELEMETRY=false אם אינכם מעוניינים שאירוע ה-onboarding יישלח לשרת המרוחק.

הערך ADMIN_API_KEY מושווה מול ה-header מסוג X-API-Key באמצעות secrets.compare_digest, והתאמה ביניהם מדלגת לחלוטין על חיפוש המפתח בבסיס הנתונים. נקודות קצה (endpoints) של זיכרון מקבלות את אישור הגישה הזה ללא זיהוי משתמש; נקודות קצה הדורשות משתמש יחזרו להשתמש בחשבון הראשון. נקודות קצה המיועדות למנהלים בלבד מקבלות אותו גם לפני שקיים חשבון כלשהו. זהו אישור גישה ברמת root עבור כל ה-API. התייחסו אליו בהתאם: ללא שמירה בהיסטוריית ה-shell, ללא העלאה ל-git, וללא הדבקה שלו בתוך שורת פקודה. המדריכים יצירת קובצי env ומקומות שבהם סודות דולפים מהם ו-שמירה על מפתחות API מחוץ להקשר של סוכן רלוונטיים כאן באופן ישיר, כיוון שהקוראים לשרת זה הם סוכנים.

ערכים הנטענים מתוך env_file נמצאים בסביבת המכולה, ו-docker inspect מדפיס אותם במלואם. כל מי שנמצא בקבוצה docker יכול לקרוא אותם, וכל מי שנמצא בקבוצה docker הוא למעשה בעל הרשאות root על המארח.

הצבת TLS לפני ה-API במקום פתיחת פורט 8888

ה-API מאזין בכתובת 127.0.0.1:8888 ולוח הבקרה בכתובת 127.0.0.1:3000. ה-Nginx מבצע TLS termination בפורט 443 ומנתב את התעבורה לשניהם.

server {
    listen 443 ssl;
    server_name mem0.example.com;

    ssl_certificate     /etc/letsencrypt/live/mem0.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/mem0.example.com/privkey.pem;

    location ~ ^/(memories|search|configure|reset|generate-instructions|auth|api-keys|entities|requests|docs|openapi.json) {
        proxy_pass http://127.0.0.1:8888;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_read_timeout 180s;
    }

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

קוד הדפדפן של לוח הבקרה קורא לכל נתיבי ה-API לפי התבנית ב-NEXT_PUBLIC_API_URL, כולל /entities ו-/requests. השמטה של אחד מהם תגרום ל-Nginx להעביר את הקריאה ל-Next.js, כך שדף לוח הבקרה יקבל שגיאת 404 במקום הנתונים הדרושים.

proxy_read_timeout חשוב יותר ממה שהוא נראה. קריאת הוספה (add) חוסמת את התהליך בזמן שמודל השפה קורא את השיחה ומחלץ עובדות. מודל 8B מקומי על גבי ה-CPU לוקח לעיתים קרובות יותר זמן מברירת המחדל של Nginx העומדת על 60 שניות. במקרה כזה, הקורא יראה 504 Gateway Time-out בזמן שהמודל עדיין עובד והזיכרון עדיין נכתב. התוצאה היא זיכרון שדווח עליו ככזה שנכשל.

סגרו את שאר הפורטים באמצעות מדיניות ברירת מחדל של דחייה ב-ufw, והשאירו פתוחים רק את 22, 80 ו-443. הנפיקו את התעודה באמצעות certbot על Ubuntu 24.04 מאחורי nginx. פורט 80 חייב להישאר נגיש כיוון שתהליך העבודה משתמש באתגר HTTP-01, ש-Let's Encrypt מריצה רק בפורט 80, בעת ההנפקה ובכל חידוש. סגירה של פורט 80 מחייבת מעבר ל-DNS-01, או ל-TLS-ALPN-01 בפורט 443 עם לקוח ACME תואם. אם השרת כבר מריץ יישומים אחרים עם ניתוב Traefik למספר יישומי Compose, הוסיפו את mem0 לנתב הקיים במקום להתקין proxy נוסף.

בדיקת תקינות (Smoke test): הוספת זיכרון וקריאתו בחזרה

export MEM0_KEY='<the ADMIN_API_KEY from .env>'

curl -sS -X POST http://127.0.0.1:8888/memories \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $MEM0_KEY" \
  -d '{"messages":[{"role":"user","content":"I deploy with Docker Compose and I run Postgres 17."}],"user_id":"smoke"}'

תגובה תקינה היא אובייקט JSON הכולל רשימת results, כאשר כל רשומה מכילה id, את טקסט ה-memory שחולץ, ו-"event": "ADD". האלגוריתם הנוכחי מחזיר אירועי ADD בלבד. אירועי UPDATE ו-DELETE הוסרו, לכן היעדרם אינו מהווה באג.

curl -sS -X POST http://127.0.0.1:8888/search \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $MEM0_KEY" \
  -d '{"query":"which database do I run?","filters":{"user_id":"smoke"},"top_k":5}'

העובדה אודות Postgres 17 אמורה לחזור עם ציון (score). העבירו את המזהה בתוך filters, כפי שמוצג. שימוש ב-user_id ברמה העליונה עדיין עובד, והשרת מתעד ב-logs את Top-level user_id in /search is deprecated. Use filters={"user_id": "..."} instead. בכל פעם שאתם משתמשים בו.

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

curl -sS -X DELETE "http://127.0.0.1:8888/memories?user_id=smoke" \
  -H "X-API-Key: $MEM0_KEY"

אם החיפוש מחזיר פחות שורות מהצפוי, בדקו את ערכי ברירת המחדל לפני שאתם מאשימים את מנגנון השליפה. בגרסה הנוכחית, top_k מוגדר כברירת מחדל ל-20 (ירידה מ-100), ו-threshold מוגדר כברירת מחדל ל-0.1 במקום ללא הגבלה, כך שהתאמות חלשות מסוננות כעת עבורכם. ברגע שזה עובד מול curl, אלו אותם נקודות קצה (endpoints) שתחברו לסוכן (agent), בין אם ישירות ובין אם דרך שרת MCP שרץ על אותו VPS.

הרצת mem0 ללא מפתח OpenAI כלל

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

LLM provider 'ollama' is not bundled in this image. Bundled providers: openai, anthropic, gemini. To use another provider, install its Python package, rebuild the container, and extend BUNDLED_LLM_PROVIDERS in server/main.py.

אין צורך לבנות דבר מחדש. Ollama מציע API תואם OpenAI ב-/v1, המכסה את /v1/chat/completions ו-/v1/embeddings, וה-provider של mem0 עבור OpenAI מקבל openai_base_url. כוונו את המפתח הזה ל-Ollama והבדיקה המובנית תעבור, כיוון שה-provider הוא אכן openai. רק הכתובת משתנה.

הוסיפו את Ollama לאותו פרויקט Compose:

  ollama:
    image: ollama/ollama
    restart: unless-stopped
    networks: [mem0_network]
    ports:
      - "127.0.0.1:11434:11434"
    volumes:
      - ollama_models:/root/.ollama

הוסיפו את ollama_models: תחת המפתח ברמה העליונה volumes:, ולאחר מכן משכו מודל צ'אט אחד ומודל embedding אחד:

docker compose up -d ollama
docker compose exec ollama ollama pull llama3.1:8b
docker compose exec ollama ollama pull nomic-embed-text

אם Ollama כבר רץ על המארח כיחידת systemd, כפי שמתואר ב-הרצת Ollama ישירות על VPS, אל תכוונו את ה-container ל-127.0.0.1:11434. בתוך ה-container של mem0, ה-127.0.0.1 הוא ה-container של mem0 עצמו. תנו לשירות mem0 את extra_hosts: ["host.docker.internal:host-gateway"], הגדירו את Environment="OLLAMA_HOST=0.0.0.0:11434" ב-drop-in של systemd כדי ש-Ollama יאזין לכתובת שה-bridge יכול להגיע אליה, ושמרו על פורט 11434 חסום ב-firewall.

שאלו את המודל מהו ממד ה-embedding שלו לפני הגדרת דבר מה

צעד זה קובע האם ה-retrieval יעבוד בכלל.

מאגר ה-pgvector של mem0 יוצר את הטבלה שלו עם רוחב וקטור קבוע, vector vector(1536), כיוון ש-embedding_model_dims מוגדר כברירת מחדל ל-1536, הרוחב של text-embedding-3-small של OpenAI. nomic-embed-text מחזיר 768 ערכים. שום דבר בתוך mem0 לא משווה בין שני המספרים הללו, לכן אי-ההתאמה צפה מ-Postgres ב-insert הראשון:

expected 1536 dimensions, not 768

אל תסמכו גם על המספר בפסקה זו. שאלו את המודל:

curl -sS http://127.0.0.1:11434/v1/embeddings \
  -H "Content-Type: application/json" \
  -d '{"model":"nomic-embed-text","input":"dimension check"}' \
  | python3 -c "import json,sys; print(len(json.load(sys.stdin)['data'][0]['embedding']))"

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

{
  "vector_store": {
    "provider": "pgvector",
    "config": {
      "host": "postgres",
      "port": 5432,
      "dbname": "postgres",
      "user": "postgres",
      "password": "<POSTGRES_PASSWORD from .env>",
      "collection_name": "memories_local_768",
      "embedding_model_dims": 768
    }
  },
  "llm": {
    "provider": "openai",
    "config": {
      "model": "llama3.1:8b",
      "api_key": "ollama",
      "openai_base_url": "http://ollama:11434/v1",
      "temperature": 0.2
    }
  },
  "embedder": {
    "provider": "openai",
    "config": {
      "model": "nomic-embed-text",
      "api_key": "ollama",
      "openai_base_url": "http://ollama:11434/v1"
    }
  }
}
curl -sS -X POST http://127.0.0.1:8888/configure \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $MEM0_KEY" \
  -d @config.json

curl -sS http://127.0.0.1:8888/configure -H "X-API-Key: $MEM0_KEY"

הקריאה השנייה קוראת את התצורה בחזרה, וזו הבדיקה לכך שהכתיבה הצליחה. לאחר מכן חזרו על בדיקת התקינות (smoke test) שלעיל.

ארבעה פרטים ב-JSON הזה אינם מובנים מאליהם, וכל אחד מהם גורם לתקלה אם תטעו בו.

api_key הוא המחרוזת ollama, ו-Ollama מתעלם מהערך שלה. היא לא יכולה להיות ריקה, כיוון שספריית ה-client של OpenAI מעלה שגיאה לפני שכל בקשה עוזבת את התהליך כאשר לא מוגדר מפתח. כל מחרוזת שאינה ריקה תעבוד.

embedding_model_dims מוגדר על ה-vector store, ובכוונה אין embedding_dims על ה-embedder. mem0 שולח את הפרמטר dimensions של OpenAI רק כאשר מגדירים את embedding_dims, ו-backends שאינם מממשים Matryoshka truncation דוחים את הפרמטר הזה על הסף. הגדירו את הרוחב במקום שבו הטבלה נוצרת, והניחו ל-embedder.

collection_name הוא חדש. mem0 יוצר את הטבלה שלו עם CREATE TABLE IF NOT EXISTS, לכן כיוון רוחב שונה ל-collection קיים לא עושה דבר: עמודת ה-vector(1536) הישנה נשארת, וכל פעולת insert נכשלת. שינוי רוחב דורש שם collection חדש, או מחיקה ידנית של הטבלה הישנה.

המארח ב-openai_base_url הוא שם השירות ב-Compose, כלומר ollama, ולא localhost. Containers מזהים זה את זה לפי שם השירות ברשת המשותפת שלהם.

מהו המחיר של מסלול מקומי לחלוטין

היו כנים עם עצמכם לגבי האיכות. תוצאות ה-benchmark המובילות של mem0 מגיעות מהפלטפורמה המנוהלת שלהם, אשר לפי ה-README כוללת אופטימיזציות קנייניות שאינן זמינות ב-SDK בקוד פתוח, ורצות על ערימת מודלים שלא צוינה. מחקר ה-LOCOMO המקורי הריץ כל קריאת מודל על GPT-4o-mini, מודל מאוחסן. כך או כך, התייחסו לתוצאות הללו כאל תקרה ולא כאל תחזית עבור מודל 8B על ה-VPS שלכם. מודל קטן כותב עובדות מעורפלות יותר, ולעיתים מחזיר טקסט חופשי במקום שבו התבקש JSON, מה שמופיע כקריאת add שמחזירה רשימת results ריקה ללא שגיאה.

מהירות היא העלות השנייה. חילוץ (extraction) מבוסס CPU בלבד לוקח שניות לכל קריאת add, וכל הודעה שאתם שומרים משלמת את המחיר הזה. מודל שמרחיב מעבר ל-JSON שהתבקש מחמיר את המצב, לכן הגבלת התשובה עם num_predict מציבה תקרה למשך הזמן שקריאת add בודדת יכולה לרוץ. אם ה-latency הזה קריטי, VPS עם GPU מחובר הוא הפתרון הכן. הוספת ליבות CPU למודל 8B עוזרת הרבה פחות ממה שאנשים מצפים. החלפת המודל היא מנוף זול יותר מהחלפת המכונה, ו-Nemotron 3.5 Lightning על VPS נותן לכם את ה-tag למשיכה, את ה-RAM הנדרש, ואת התשובה לשאלה האם ביצועי CPU בלבד מספיקים לצרכים שלכם.

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

גיבויים: קיימים שני מסדי נתונים, לא אחד

הטעות הנפוצה ביותר בגיבוי mem0 היא ביצוע dump למסד נתונים יחיד. init-db.sh יוצר את mem0_app לצד מסד הנתונים ברירת המחדל postgres, והם מכילים נתונים שונים. מסד הנתונים postgres מכיל את אוספי ה-pgvector, שהם הזיכרונות עצמם. mem0_app מכיל משתמשים, סשנים, מפתחות API ולוגים של בקשות. כל יישום בהתקנה עצמית מפצל את המצב שלו בדרך שלו, וזו הסיבה ש-שני שרתי תמונות המבצעים את אותה עבודה עדיין זקוקים לפקודות גיבוי שונות; לכן, קראו מה היישום שלכם מאחסן לפני שאתם סומכים על קובץ dump. בקצה השני של הסקאלה נמצאים מקרים כמו ספריית Jellyfin המשוחזרת כחנות וידאו משנות ה-90, שקוראת את כל הקטלוג שלה משירות אחר ולכן זקוקה בקושי ליותר מהעתקה של קובצי התצורה שלה, בעוד ש-mem0 זקוק לשני מסדי הנתונים, אחרת השחזור חסר תועלת.

שחזור של postgres בלבד יחזיר את הזיכרונות, אך כל החשבונות ומפתחות ה-API יאבדו, כך שלא ניתן יהיה לבצע אימות כדי לקרוא אותם. בצעו dump לשניהם, בתוספת התפקידים (roles), בפקודה אחת:

docker compose exec -T postgres pg_dumpall -U postgres --clean \
  | gzip > "mem0-$(date +%F).sql.gz"

נפח ההיסטוריה (history volume) נפרד מ-Postgres וזקוק להעתקה משלו:

docker run --rm -v mem0_mem0_history:/data -v "$PWD:/backup" \
  alpine tar czf /backup/mem0-history.tgz -C /data .

Docker מוסיף תחילית של שם הפרויקט לשמות הנפחים, לכן ודאו מהם השמות שלכם באמצעות docker volume ls לפני שאתם מניחים שמדובר ב-mem0_mem0_history.

בצעו שחזור לתוך מכולה ריקה (scratch container) ובדקו את מספר השורות לפני שאתם מסתמכים על הנתונים:

gunzip -c mem0-2026-08-03.sql.gz \
  | docker compose exec -T postgres psql -U postgres -d postgres

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

מצבי כשל והודעות השגיאה המדויקות שתראו

{"detail":"Authentication required. Provide a Bearer token or X-API-Key header."} מציין שהכותרת חסרה או שגויה. השם הוא X-API-Key, ו-curl שולח שמות כותרות כפי שהם.

{"detail":"At least one identifier (user_id, agent_id, run_id) is required."} בעת ביצוע add מציין שהבקשה לא כללה אף אחד מהם. זיכרון חייב להיות משויך למשהו, כיוון שמסנני החיפוש פועלים בדיוק על שדות אלו.

LLM provider 'ollama' is not bundled in this image עם קוד HTTP 400 מציין ששלחתם "provider": "ollama". השתמשו ב-"provider": "openai" כאשר openai_base_url מצביע על Ollama.

expected 1536 dimensions, not 768 מ-Postgres מציין שהאוסף נוצר ברוחב מסוים, אך המקודד (embedder) מחזיר רוחב אחר. הגדירו embedding_model_dims ב-vector store והשתמשו ב-collection_name חדש.

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

Connection refused בלוגים של mem0 בעת ניסיון גישה ל-Ollama מציין בדרך כלל 127.0.0.1 בתוך openai_base_url. בתוך המכולה, כתובת זו מתייחסת למכולה עצמה. השתמשו בשם השירות, או ב-host gateway אם Ollama רץ על המארח.

504 Gateway Time-out מ-nginx בעת ביצוע add מציין שהמודל לקח זמן רב יותר מ-proxy_read_timeout. העלו את הערך, ובדקו אם הזיכרון נכתב בכל זאת לפני שתנסו את הבקשה שוב.

exit code 137 במהלך docker compose up --build מציין שתהליך נקטל באמצעות SIGKILL, כיוון שסיגנל קטלני N מדווח כ-128 + N, ו-SIGKILL הוא סיגנל 9. בזמן בניית ה-dashboard על שרת VPS קטן, הגורם הסביר ביותר הוא ה-out-of-memory killer. לכן, הריצו את בדיקת dmesg מהסעיף הראשון לפני שתנקטו פעולה. אם הבדיקה מראה תהליך שנקטל, הוסיפו swap, או בנו את ה-image על מכונה חזקה יותר ודחפו אותה ל-registry.

error: port 3000 is already in use מגיע מיעד ה-make up של המאגר, שמסרב לעלות כאשר פורטים 3000 או 8888 תפוסים. מצאו את התהליך שתופס אותם באמצעות lsof -iTCP:3000 -sTCP:LISTEN.

FAQ

האם אני עדיין זקוק ל-Neo4j כדי להריץ את mem0 עם זיכרון גרפי?

לא. אלגוריתם הזיכרון החדש, ששוחרר באפריל 2026, הסיר את מפתחות התצורה graph_store ו-enable_graph מ-SDK הקוד הפתוח. חילוץ ישויות מתבצע כעת במהלך פעולת הוספה רגילה וכותב לאוסף pgvector שני בשם <collection_name>_entities, לכן אין צורך במסד נתונים גרפי חיצוני, אין קונטיינר נוסף ואין שלב הגדרה. המחיר הוא שהשדה relations בתוצאות חיפוש אינו קיים עוד. ישויות מעלות כעת את הדירוג של זיכרון במקום לספק קשתות למעבר, לכן יישום שסרק את הקשרים הללו זקוק למאגר גרפים משלו מחוץ ל-mem0.

מהו ה-VPS הקטן ביותר שמריץ שרת mem0 בהתקנה עצמית?

הערכת הגודל מ-2026-10-25 עמדה על 2 GB של RAM וכ-4 GB של שטח דיסק פנוי עבור קונטיינר ה-API, Postgres ולוח הבקרה, כאשר מודל השפה מאוחסן במקום אחר. הרגע הקריטי הוא ה-build הראשון, כיוון שקימפול לוח הבקרה ב-Next.js צורך יותר זיכרון מאשר הרצתו. אם ה-build מסתיים ב-exit code 137, בדקו אם אירע out-of-memory kill. עבור Ollama על אותו שרת, הערכה זו אפשרה בערך 6 GB עבור מודל 8B בקוונטיזציה של 4-bit ו-8 GB עבור כל ה-stack. מדדו את ה-build והמודל שלכם לפני שתתייחסו להערכות אלו כאל מינימום.

האם ניתן להריץ את mem0 ללא מפתח API של OpenAI?

כן, דרך ה-endpoint התואם ל-OpenAI של Ollama. הגדרת "provider": "ollama" נכשלת, כיוון שאימג' השרת כולל רק את הספריות openai, anthropic ו-gemini ומחזיר HTTP 400. במקום זאת, שמרו על "provider": "openai" והגדירו את "openai_base_url": "http://ollama:11434/v1" עם כל api_key שאינו ריק, עבור ה-llm וה-embedder כאחד. Ollama מתעלמת מהמפתח, ובדיקת הספק המצורפת עוברת כיוון שהספק הוא אכן openai.

מדוע mem0 לא מחזיר תוצאות לאחר מעבר למודל הטמעה (embedding) מקומי?

מכיוון שטבלת ה-pgvector נוצרה ברוחב קבוע. embedding_model_dims מוגדר כברירת מחדל ל-1536, nomic-embed-text מחזיר 768, ו-Postgres דוחה את ה-insert עם expected 1536 dimensions, not 768. mem0 יוצר את הטבלה עם CREATE TABLE IF NOT EXISTS, לכן שינוי המספר בלבד אינו משפיע על אוסף קיים. הגדירו את embedding_model_dims לרוחב האמיתי של המודל שלכם, אשרו את הרוחב על ידי קריאה ל-/v1/embeddings וספירת הערכים שהוא מחזיר, ותנו ל-vector store שם collection_name חדש באותו זמן.

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