SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-11-20

VPS पर mem0 को self-host कैसे करें: पूरी गाइड

अपने VPS पर mem0 memory server को self-host करने का तरीका जानें। इसमें 1GB RAM की न्यूनतम आवश्यकता, Docker Compose सेटअप, TLS कॉन्फ़िगरेशन और Ollama के साथ स्थानीय एकीकरण शामिल है।

VPS पर mem0 को self-host करने की वास्तविक RAM लागत

mem0 को self-host करने का अर्थ है तीन containers चलाना: FastAPI memory server, pgvector extension के साथ Postgres, और एक Next.js dashboard। mem0 agents के लिए एक memory layer है। आप इसमें एक conversation post करते हैं, एक language model उस conversation से स्थायी तथ्य (durable facts) निकालता है, और उन तथ्यों को vectors के रूप में store किया जाता है ताकि बाद में query करने पर प्रासंगिक जानकारी वापस मिल सके।

2026-10-25 की इस पोस्ट में sizing का अनुमान तीन containers के लिए लगभग 1 GB memory और images build होने के बाद 3 से 4 GB disk का था। जब language model कहीं और स्थित हो, तो 2 GB VPS की सिफारिश की गई थी। Ollama के माध्यम से उसी box पर चल रहे 4-bit quantised 8B model के लिए, अनुमान केवल model के लिए लगभग 6 GB और पूर्ण local build के लिए 8 GB था।

किसी blog post के इन आंकड़ों को अंतिम न मानें, जिसमें यह पोस्ट भी शामिल है। जो stack आपने वास्तव में build किया है, उसे मापें।

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

docker stats Linux पर cache usage को घटाकर, प्रति container memory usage को print करता है। docker system df -v प्रत्येक image और प्रत्येक volume द्वारा ली गई disk space को print करता है।

Steady state peak नहीं होता है। docker compose up -d --build Next.js dashboard को compile करता है, और वह Node build पूरे install का सबसे अधिक संसाधन लेने वाला क्षण होता है। यदि build exit code 137 के साथ समाप्त होता है, तो out-of-memory kill की जाँच करें। Docker bug ढूँढने से पहले कारण की पुष्टि करें:

dmesg -T | grep -i "killed process"

यदि आपको लगता है कि आपकी आवश्यकता के लिए server बहुत अधिक machinery है, तो छोटे विकल्प भी मौजूद हैं। बिना किसी server के local agent memory store और Claude Code के भीतर रहने वाली memory दोनों ही database के उपयोग से बचते हैं। जब कई agents, या कई machines को एक ही memory को पढ़ने की आवश्यकता हो, तब यहाँ वापस आएँ।

क्या मुझे mem0 graph memory के लिए Neo4j की आवश्यकता है?

नहीं। यदि कोई गाइड आपको Neo4j container जोड़ने के लिए कहती है, तो वह गाइड कोड से पुरानी है।

mem0 में graph memory का अर्थ पहले एक बाहरी graph database से होता था, जिसे graph_store key के अंतर्गत कॉन्फ़िगर किया जाता था और enable_graph को true पर सेट किया जाता था। अप्रैल 2026 में जारी किए गए नए memory algorithm ने open source SDK से इन दोनों keys को हटा दिया है। Entity extraction अब सामान्य add path के भीतर चलता है, और entities को आपके मुख्य collection के नाम के साथ _entities जोड़कर बनाए गए दूसरे pgvector collection में लिखा जाता है। इसके लिए किसी setup चरण की आवश्यकता नहीं है: वह collection पहली बार उपयोग करने पर स्वतः बन जाता है, इसलिए अगली add call पर built-in entity linking काम करना शुरू कर देता है।

Graph store को हटाने से एक JVM container, उसकी heap memory और कई सौ megabytes की image की बचत होती है। 2 GB VPS पर यह अंतर service के सुचारू रूप से चलने और swapping के बीच का होता है।

यहाँ स्पष्ट रूप से बताया गया है कि आप क्या छोड़ रहे हैं। Search results में पहले एक relations field होता था जो entities के बीच के edges को सूचीबद्ध करता था। वह field अब हटा दिया गया है। Entity matches अब combined score में memory की स्थिति को ऊपर ले जाते हैं, और ऐसी कोई संरचना नहीं है जिसे आप traverse कर सकें। यदि आपका application उन relationships का उपयोग करता था, तो mem0 अब उन्हें hold नहीं करता है, और आपको mem0 के बाहर अपना स्वयं का graph database रखना होगा, जिसे आपके अपने कोड द्वारा feed किया जाएगा।

रिपॉजिटरी में मौजूद compose file एक development compose है

server/docker-compose.yaml, name: mem0-dev को घोषित करता है, और इसका यही अर्थ है। इसे चलाने से पहले पढ़ें, क्योंकि इसमें मौजूद पाँच चीजें सर्वर के लिए गलत हैं।

  • यह server/dev.Dockerfile से build होता है और .:/app के साथ आपके checkout को image के ऊपर mount करता है, इसलिए container वही चलाता है जो उस directory में है, न कि वह जिसे आपने build किया था।
  • इसका command 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 है। यह हर start पर PyPI से mem0ai को फिर से install करता है, इसलिए आपके सर्वर पर चलने वाला version उस restart के दौरान बदल सकता है जिसे आप upgrade नहीं मानते थे।
  • उसी pip step का मतलब है कि outbound network के बिना restart होने पर uvicorn के चलने से पहले ही वह fail हो जाएगा। आपका memory सर्वर तब down हो जाता है क्योंकि PyPI तक पहुँचा नहीं जा सका।
  • --reload, uvicorn के file watcher को start करता है। यह code edit करने पर process को restart करने के लिए होता है, और production में बिना किसी उपयोगी काम के यह memory और एक अतिरिक्त process की खपत करता है। production Dockerfile में भी उसके CMD में --reload होता है, इसलिए आप किसी भी तरह command को override कर देते हैं।
  • प्रकाशित ports "8888:8000", "8432:5432" और "3000:3000" हैं। बिना किसी address के प्रकाशित port 0.0.0.0 पर bind होता है, इसलिए stack शुरू होते ही Postgres 8432 पर public internet को जवाब देने लगता है।

यह आखिरी बिंदु अपनी चेतावनी का हकदार है। Docker, ufw द्वारा प्रबंधित chain से पहले अपने नियम लिखकर port प्रकाशित करता है, इसलिए ufw deny 8432 किसी प्रकाशित container port को बंद नहीं करता है। Docker द्वारा सीधे ufw के पार ports प्रकाशित करना इसमें शामिल नियमों के बारे में विस्तार से बताता है।

एक वास्तविक सर्वर के लिए compose file

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 उन connections को केवल उसी box से स्वीकार करे। बाहर से आने वाली हर चीज़ reverse proxy के माध्यम से आती है, जो certificate रखने वाली एकमात्र चीज़ है।

Postgres में कोई ports ब्लॉक नहीं है। mem0 container उस तक mem0_network के माध्यम से service name द्वारा पहुँचता है, इसलिए 8432 को publish करने से आपको कुछ नहीं मिलता और एक open port का जोखिम बढ़ता है। जब आपको shell की आवश्यकता हो तो docker compose exec postgres psql -U postgres का उपयोग करें।

History, ./history bind mount से हटकर एक named volume पर चली जाती है। Bind mount डेटा को इस host पर एक path और एक uid से जोड़ता है, जबकि named volume एक ऐसा object है जिसका Docker snapshot ले सकता है और उसे move कर सकता है। Named volumes बनाम bind mounts बताता है कि कौन सा कब सही है।

Command --reload को हटा देती है और alembic upgrade head को रखती है। उस migration step को बनाए रखें। इसके बिना, app बिना tables वाले database के साथ boot होती है, और हर request पहली query पर ही fail हो जाती है।

NEXT_PUBLIC_API_URL वह URL है जिसे आपका browser call करता है, इसलिए यह public HTTPS address होना चाहिए, न कि http://mem0:8000। Next.js build time पर NEXT_PUBLIC_ values को inline करता है, लेकिन इस dashboard की image में एक placeholder होता है, और container start होने पर इसका entrypoint container की वास्तविक value को swap कर देता है। इसलिए इसे बदलने के लिए docker compose up -d mem0-dashboard की आवश्यकता होती है, जो container को recreate करता है, न कि rebuild। docker compose restart mem0-dashboard पुराने container का पुन: उपयोग करता है, जिसकी files में पहले से ही पुरानी value होती है, और dashboard गलत host को call करना जारी रखता है।

Secrets .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 को सेट करें।

ADMIN_API_KEY की तुलना secrets.compare_digest के साथ X-API-Key हेडर से की जाती है, और मैच होने पर डेटाबेस में प्रति-की (per-key) लुकअप पूरी तरह से छोड़ दिया जाता है। मेमोरी एंडपॉइंट्स उस क्रेडेंशियल को बिना किसी यूजर को रिजॉल्व किए स्वीकार कर लेते हैं; जिन एंडपॉइंट्स के लिए यूजर की आवश्यकता होती है, वे पहले अकाउंट पर वापस चले जाते हैं। एडमिन-ओनली एंडपॉइंट्स भी पहले अकाउंट के अस्तित्व में आने से पहले इसे स्वीकार कर लेते हैं। यह पूरे API के लिए एक रूट क्रेडेंशियल है। इसे उसी तरह संभालें: कोई शेल हिस्ट्री नहीं, कोई git नहीं, और इसे किसी प्रॉम्प्ट में पेस्ट न करें। Compose env फाइलें और उनसे सीक्रेट्स लीक होने के स्थान और API कीज़ को एजेंट के कॉन्टेक्स्ट से बाहर रखना दोनों यहाँ सीधे लागू होते हैं, क्योंकि इस सर्वर को कॉल करने वाले एजेंट ही होते हैं।

env_file से लोड किए गए मान कंटेनर एनवायरनमेंट में रहते हैं, और docker inspect उन्हें पूरा प्रिंट कर देता है। docker ग्रुप का कोई भी व्यक्ति उन्हें पढ़ सकता है, और docker ग्रुप का कोई भी व्यक्ति होस्ट पर प्रभावी रूप से रूट होता है।

8888 port खोलने के बजाय API के सामने TLS लगाएँ

API 127.0.0.1:8888 पर और dashboard 127.0.0.1:3000 पर जवाब देता है। nginx 443 पर TLS (transport layer security) को terminate करता है और दोनों पर traffic forward करता है।

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;
    }
}

Dashboard का browser code NEXT_PUBLIC_API_URL पर उस pattern के हर API path को call करता है, जिसमें /entities और /requests शामिल हैं। यदि आप एक को भी छोड़ देते हैं, तो nginx उस call को Next.js को सौंप देता है, जिससे जिस dashboard page को इसकी आवश्यकता होती है, उसे data के बजाय 404 error मिलता है।

proxy_read_timeout जितना दिखता है उससे कहीं अधिक महत्वपूर्ण है। एक add call तब तक block रहती है जब तक language model conversation को पढ़कर facts extract नहीं कर लेता। CPU पर चलने वाला एक local 8B model अक्सर nginx के 60 second के default timeout से अधिक समय लेता है, और फिर caller को 504 Gateway Time-out दिखाई देता है जबकि model अभी भी काम कर रहा होता है और memory अभी भी लिखी जा रही होती है। अंत में आपको एक ऐसी memory मिलती है जिसके बारे में आपको बताया गया था कि वह fail हो गई है।

बाकी ports को a default deny ufw policy के साथ बंद कर दें, केवल 22, 80 और 443 को खुला रखें। certbot on Ubuntu 24.04 behind nginx का उपयोग करके certificate जारी करें। Port 80 को reachable रखना आवश्यक है क्योंकि वह workflow HTTP-01 challenge का उपयोग करता है, जिसे Let's Encrypt केवल port 80 पर ही चलाता है, issuance के समय और हर renewal पर। 80 को बंद रखने का अर्थ है DNS-01 पर स्विच करना, या port 443 पर एक compatible ACME client के साथ TLS-ALPN-01 का उपयोग करना। यदि box पहले से ही Traefik routing several Compose apps के साथ अन्य apps को handle कर रहा है, तो दूसरा proxy install करने के बजाय उस router में mem0 को जोड़ें।

Smoke test: एक memory जोड़ें और उसे वापस पढ़ें

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"}'

एक सही response एक JSON object होता है जिसमें results list होती है, और प्रत्येक entry में एक id, निकाला गया memory text, और "event": "ADD" होता है। वर्तमान algorithm केवल ADD events लौटाता है। UPDATE और DELETE events को हटा दिया गया है, इसलिए उनकी अनुपस्थिति कोई bug नहीं है।

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 के साथ वापस आना चाहिए। जैसा कि दिखाया गया है, identifier को filters के अंदर पास करें। एक top level user_id अभी भी काम करता है, और हर बार जब आप इसका उपयोग करते हैं तो सर्वर Top-level user_id in /search is deprecated. Use filters={"user_id": "..."} instead. log करता है।

अपने बाद सफाई करें ताकि test data वास्तविक searches को दूषित न करे:

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

यदि search आपकी अपेक्षा से कम rows लौटाती है, तो retrieval को दोष देने से पहले defaults की जाँच करें। वर्तमान release में top_k का default 100 से घटकर 20 हो गया है, और threshold का default none के बजाय 0.1 है, इसलिए अब weak matches आपके लिए filter कर दिए जाते हैं। एक बार जब यह curl पर काम करने लगे, तो यही endpoints हैं जिन्हें आप एक agent में wire करते हैं, चाहे सीधे या उसी VPS पर चल रहे MCP server के माध्यम से।

बिना OpenAI key के mem0 चलाना

सबसे पहले उस बाधा को देखें जिसका सामना आप शुरुआती पांच मिनट में करेंगे। सर्वर इमेज में provider libraries का एक निश्चित सेट होता है, और /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.

आपको कुछ भी फिर से बनाने (rebuild) की आवश्यकता नहीं है। Ollama, /v1 पर एक OpenAI-compatible API प्रदान करता है, जो /v1/chat/completions और /v1/embeddings को कवर करता है, और mem0 का openai provider एक openai_base_url स्वीकार करता है। उस key को Ollama की ओर निर्देशित करें और बंडल किया गया चेक पास हो जाएगा, क्योंकि provider वास्तव में openai है। केवल पता (address) बदलता है।

Ollama को उसी Compose प्रोजेक्ट में जोड़ें:

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

टॉप-लेवल volumes: key के अंतर्गत ollama_models: जोड़ें, फिर एक chat model और एक embedding model पुल करें:

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

यदि Ollama पहले से ही host पर systemd unit के रूप में चल रहा है, जैसा कि VPS पर सीधे Ollama चलाना में बताया गया है, तो container को 127.0.0.1:11434 की ओर निर्देशित न करें। mem0 container के अंदर, 127.0.0.1 स्वयं mem0 container है। mem0 service को extra_hosts: ["host.docker.internal:host-gateway"] दें, systemd drop-in में Environment="OLLAMA_HOST=0.0.0.0:11434" सेट करें ताकि Ollama उस पते पर listen करे जिसे bridge एक्सेस कर सके, और firewall पर 11434 को बंद रखें।

कॉन्फ़िगरेशन से पहले मॉडल से उसकी embedding dimension पूछें

यह एक कदम तय करता है कि retrieval काम करेगा या नहीं।

mem0 का pgvector store अपनी table को एक निश्चित vector width, vector vector(1536) के साथ बनाता है, क्योंकि embedding_model_dims डिफ़ॉल्ट रूप से 1536 पर सेट होता है, जो OpenAI के text-embedding-3-small की चौड़ाई है। nomic-embed-text 768 मान लौटाता है। mem0 के अंदर कोई भी उन दो संख्याओं की तुलना नहीं करता है, इसलिए पहले insert पर Postgres से बेमेल (mismatch) सामने आता है:

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 को करना है। कॉन्फ़िगरेशन को एक फ़ाइल में लिखें, क्योंकि shell quoting के माध्यम से Postgres पासवर्ड पेस्ट करने से production में टाइपिंग की गलतियाँ होती हैं।

{
  "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"

दूसरा कॉल कॉन्फ़िगरेशन को वापस पढ़ता है, जो यह जांचने का तरीका है कि write सफल रहा। फिर ऊपर दिए गए smoke test को दोहराएं।

उस JSON में चार विवरण स्पष्ट नहीं हैं, और यदि आप उन्हें गलत करते हैं तो प्रत्येक कुछ न कुछ तोड़ देता है।

api_key एक स्ट्रिंग ollama है, और Ollama इसके मान को अनदेखा करता है। यह खाली नहीं हो सकता, क्योंकि जब कोई key सेट नहीं होती है, तो OpenAI client library किसी भी request के process से बाहर निकलने से पहले error देती है। कोई भी गैर-खाली स्ट्रिंग काम करेगी।

embedding_model_dims vector store पर जाता है, और embedder पर जानबूझकर कोई embedding_dims नहीं है। mem0 केवल तब OpenAI dimensions पैरामीटर भेजता है जब आप embedding_dims सेट करते हैं, और जो backends Matryoshka truncation लागू नहीं करते हैं, वे उस पैरामीटर को सीधे अस्वीकार कर देते हैं। चौड़ाई वहां सेट करें जहां table बनाई जाती है, और embedder को न छेड़ें।

collection_name नया है। mem0 अपनी table को CREATE TABLE IF NOT EXISTS के साथ बनाता है, इसलिए किसी मौजूदा collection पर अलग चौड़ाई निर्देशित करने से कुछ नहीं होता: पुराना vector(1536) कॉलम बना रहता है, और हर insert विफल हो जाता है। चौड़ाई बदलने के लिए एक नए collection नाम की आवश्यकता होती है, या आपको पुरानी table को मैन्युअल रूप से हटाना (drop) होगा।

openai_base_url में host, Compose service नाम ollama है, न कि localhost। Containers अपने साझा नेटवर्क पर एक-दूसरे को service नाम से पहचानते हैं।

पूर्णतः local path की लागत

गुणवत्ता के बारे में खुद के प्रति ईमानदार रहें। mem0 के मुख्य बेंचमार्क स्कोर उसके प्रबंधित प्लेटफ़ॉर्म से आते हैं, जिसके बारे में README कहता है कि इसमें ओपन सोर्स SDK में उपलब्ध न होने वाले proprietary optimizations शामिल हैं, जो ऐसे मॉडल स्टैक पर चलते हैं जिसका नाम नहीं दिया गया है। मूल LOCOMO परिणामों के पीछे के शोध पत्र ने हर मॉडल कॉल को GPT-4o-mini पर चलाया, जो एक hosted मॉडल था। किसी भी स्थिति में, उन स्कोर को अपने VPS पर 8B मॉडल के लिए पूर्वानुमान के बजाय एक सीमा (ceiling) के रूप में मानें। एक छोटा मॉडल अस्पष्ट तथ्य लिखता है, और कभी-कभी JSON मांगे जाने पर prose लौटाता है, जो एक add कॉल के रूप में दिखाई देता है जो बिना किसी त्रुटि के एक खाली results सूची लौटाता है।

गति दूसरी लागत है। CPU-only extraction में प्रति add कॉल सेकंड लगते हैं, और आपके द्वारा स्टोर किया गया हर संदेश इसकी कीमत चुकाता है। एक मॉडल जो JSON से आगे बड़बड़ाता है, वह इसे और खराब कर देता है, इसलिए num_predict के साथ reply को सीमित करना किसी भी एक add कॉल के चलने के समय पर एक सीमा लगाता है। यदि वह latency मायने रखती है, तो GPU वाला VPS ही इसका सही समाधान है। 8B मॉडल पर अधिक CPU cores फेंकने से लोगों की अपेक्षा से बहुत कम मदद मिलती है। मशीन बदलने की तुलना में मॉडल बदलना एक सस्ता विकल्प है, और VPS पर Nemotron 3.5 Lightning आपको पुल करने के लिए टैग, आवश्यक RAM, और यह बताता है कि क्या CPU-only गति रहने योग्य है।

आप जो भी चुनें, एक नियम लागू होता है: कभी भी एक collection के अंदर embedding models को न मिलाएं। दो अलग-अलग मॉडल जो संयोगवश एक चौड़ाई साझा करते हैं, ऐसे vectors उत्पन्न करते हैं जो तुलनीय नहीं होते हैं। Insert सफल हो जाता है, search पंक्तियाँ लौटाता है, और पंक्तियाँ गलत होती हैं, जबकि कहीं भी कोई त्रुटि रिपोर्ट नहीं होती है।

Backups: दो डेटाबेस हैं, एक नहीं

सबसे सामान्य mem0 backup गलती केवल एक database का dump लेना है। init-db.sh डिफ़ॉल्ट postgres database के साथ mem0_app बनाता है, और दोनों में अलग-अलग data रहता है। postgres database में pgvector collections रहती हैं, जो memories हैं। mem0_app में users, sessions, API keys और request logs रहते हैं। प्रत्येक self-hosted app अपना state अलग तरीके से विभाजित करता है। इसी कारण एक ही काम करने वाले दो photo servers के लिए भी अलग backup commands चाहिए। इसलिए dump पर भरोसा करने से पहले पढ़ें कि आपका app क्या-क्या store करता है। इस range के दूसरे छोर पर 90s video store के रूप में फिर से बनाई गई Jellyfin library जैसी व्यवस्था होती है। वह अपना पूरा catalogue किसी अन्य service से पढ़ती है। इसलिए उसमें अपनी configuration की copy रखना ही काफी हो सकता है। इसके विपरीत, mem0 के लिए दोनों databases चाहिए। अन्यथा restore बेकार होगा।

यदि आप केवल postgres को रिस्टोर करते हैं, तो मेमोरीज तो वापस आ जाएंगी लेकिन सभी अकाउंट्स और API keys गायब हो जाएंगी, जिससे उन्हें पढ़ने के लिए कोई भी ऑथेंटिकेट नहीं कर पाएगा। दोनों को, साथ ही रोल्स को, एक ही कमांड में डंप करें:

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

हिस्ट्री वॉल्यूम Postgres से अलग है और इसे अपनी अलग कॉपी की आवश्यकता है:

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

Docker वॉल्यूम नामों के आगे प्रोजेक्ट का नाम जोड़ता है, इसलिए mem0_mem0_history मानने से पहले docker volume ls के साथ अपने वॉल्यूम नाम की पुष्टि करें।

एक स्क्रैच कंटेनर में रिस्टोर करें और किसी भी डेटा पर भरोसा करने से पहले रो काउंट्स (row counts) की जाँच करें:

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

जिस बैकअप को आपने कभी रिस्टोर नहीं किया, वह केवल एक अनुमान है। एक बार जब डंप सही हो जाएं, तो उन्हें restic snapshots to off-site storage का उपयोग करके सर्वर से बाहर भेज दें, क्योंकि जो बैकअप उसी सर्वर पर रहता है जिसकी वह सुरक्षा कर रहा है, वह वास्तव में किसी चीज की सुरक्षा नहीं करता है।

विफलता के प्रकार और वे सटीक स्ट्रिंग्स जो आपको दिखाई देंगी

{"detail":"Authentication required. Provide a Bearer token or X-API-Key header."} का अर्थ है कि हेडर गायब है या उसकी स्पेलिंग गलत है। इसका नाम X-API-Key है, और curl हेडर के नामों को अक्षरशः भेजता है।

किसी add पर {"detail":"At least one identifier (user_id, agent_id, run_id) is required."} का अर्थ है कि अनुरोध में इनमें से कोई भी मौजूद नहीं था। मेमोरी को किसी चीज़ के दायरे में होना चाहिए, क्योंकि सर्च फिल्टर ठीक उन्हीं फील्ड्स पर काम करते हैं।

HTTP 400 के साथ LLM provider 'ollama' is not bundled in this image का अर्थ है कि आपने "provider": "ollama" भेजा है। Ollama की ओर पॉइंट किए गए openai_base_url के साथ "provider": "openai" का उपयोग करें।

Postgres से expected 1536 dimensions, not 768 का अर्थ है कि कलेक्शन एक विशेष चौड़ाई (width) पर बनाया गया था और एम्बेडेर (embedder) दूसरी चौड़ाई लौटा रहा है। वेक्टर स्टोर पर embedding_model_dims सेट करें और एक नए collection_name का उपयोग करें।

मॉडल बदलने के बाद सर्च ऐसी पंक्तियाँ लौटाता है जिनका कोई अर्थ नहीं है, और कहीं कोई त्रुटि नहीं है। चौड़ाई अभी भी मेल खाती है, इसलिए डेटाबेस ठीक काम कर रहा है, लेकिन दो मॉडल एक ही वाक्य को अलग-अलग स्थितियों में रखते हैं। एक नया कलेक्शन शुरू करें और फिर से जोड़ें।

Ollama तक पहुँचते समय mem0 लॉग्स में Connection refused का अर्थ आमतौर पर openai_base_url में 127.0.0.1 होता है। कंटेनर के अंदर वह पता कंटेनर ही होता है। सर्विस नाम का उपयोग करें, या जब Ollama होस्ट पर चल रहा हो तो host gateway का उपयोग करें।

add पर nginx से 504 Gateway Time-out का अर्थ है कि मॉडल ने proxy_read_timeout से अधिक समय लिया। इसे बढ़ाएं, और अनुरोध को पुनः प्रयास करने से पहले जांचें कि क्या मेमोरी तब भी लिखी गई थी।

docker compose up --build के दौरान exit code 137 का अर्थ है कि एक प्रोसेस को SIGKILL के साथ समाप्त कर दिया गया था, क्योंकि एक घातक सिग्नल N को 128 + N के रूप में रिपोर्ट किया जाता है और SIGKILL सिग्नल 9 है। जब डैशबोर्ड एक छोटे VPS पर बनता है, तो सबसे संभावित कारण out-of-memory killer होता है, इसलिए कार्रवाई करने से पहले पहले सेक्शन से dmesg चेक चलाएं। यदि वह एक समाप्त की गई प्रोसेस दिखाता है, तो swap जोड़ें, या किसी बड़ी मशीन पर इमेज बनाएं और उसे रजिस्ट्री में पुश करें।

error: port 3000 is already in use रेपो के make up टारगेट से आता है, जो तब शुरू होने से मना कर देता है जब 3000 या 8888 पोर्ट पहले से उपयोग में हों। lsof -iTCP:3000 -sTCP:LISTEN के साथ इसका उपयोग करने वाले ओनर (owner) का पता लगाएं।

FAQ

क्या graph memory के साथ mem0 चलाने के लिए मुझे अभी भी Neo4j की आवश्यकता है?

नहीं। अप्रैल 2026 में जारी किए गए नए memory algorithm ने open source SDK से graph_store और enable_graph configuration keys को हटा दिया है। Entity extraction अब सामान्य add प्रक्रिया के दौरान चलता है और <collection_name>_entities नामक दूसरी pgvector collection में लिखता है, इसलिए अब किसी बाहरी graph database, अतिरिक्त container या setup step की आवश्यकता नहीं है। इसका परिणाम यह है कि search results पर relations field अब मौजूद नहीं है। Entities अब memory की ranking बढ़ाती हैं, न कि आपको traverse करने के लिए edges प्रदान करती हैं, इसलिए जो application उन relationships का उपयोग करती थी, उसे mem0 के बाहर अपने स्वयं के graph store की आवश्यकता होगी।

self-hosted mem0 server चलाने के लिए सबसे छोटा VPS कौन सा है?

2026-10-25 का sizing अनुमान API container, Postgres और dashboard के लिए 2 GB RAM और लगभग 4 GB free disk था, जिसमें language model कहीं और host किया गया हो। सबसे कठिन समय पहला build होता है, क्योंकि Next.js dashboard को compile करना उसे चलाने की तुलना में अधिक memory का उपयोग करता है। यदि build exit code 137 के साथ समाप्त होता है, तो out-of-memory kill की जाँच करें। उसी सर्वर पर Ollama के लिए, उस अनुमान में 8B model के 4-bit quantisation के लिए लगभग 6 GB और पूरे stack के लिए 8 GB की अनुमति थी। उन अनुमानों को न्यूनतम मानने से पहले अपने build और model को मापें।

क्या मैं OpenAI API key के बिना mem0 चला सकता हूँ?

हाँ, Ollama के OpenAI compatible endpoint के माध्यम से। "provider": "ollama" सेट करना विफल रहता है, क्योंकि server image में केवल openai, anthropic और gemini libraries बंडल होती हैं और यह HTTP 400 return करता है। इसके बजाय "provider": "openai" को बनाए रखें और llm तथा embedder दोनों के लिए किसी भी non-empty api_key के साथ "openai_base_url": "http://ollama:11434/v1" सेट करें। Ollama key को ignore करता है, और बंडल किया गया provider check पास हो जाता है क्योंकि provider वास्तव में openai ही है।

local embedding model पर स्विच करने के बाद mem0 परिणाम क्यों नहीं देता है?

क्योंकि pgvector table एक निश्चित width पर बनाई गई थी। embedding_model_dims डिफ़ॉल्ट रूप से 1536 होता है, nomic-embed-text 768 return करता है, और Postgres expected 1536 dimensions, not 768 के साथ insert को अस्वीकार कर देता है। mem0 table को CREATE TABLE IF NOT EXISTS के साथ बनाता है, इसलिए केवल संख्या बदलने से मौजूदा collection पर कोई प्रभाव नहीं पड़ता है। embedding_model_dims को अपने model की वास्तविक width पर सेट करें, /v1/embeddings को कॉल करके और उसके द्वारा return किए गए values को गिनकर उस width की पुष्टि करें, और साथ ही vector store को एक नया collection_name दें।

क्या यह लेख उपयोगी था?