Jinsi ya ku-self-host mem0 kwenye VPS yako
Jifunze kuendesha mem0 kwenye VPS yako kwa kutumia Docker Compose. Pata mwongozo wa matumizi ya RAM, usanidi wa TLS, na jinsi ya kuunganisha Ollama kwa kumbukumbu ya wakala.
Gharama halisi ya RAM kwa ajili ya ku-self-host mem0 kwenye VPS
Ku-self-host mem0 kunamaanisha kuendesha container tatu: seva ya kumbukumbu ya FastAPI, Postgres yenye extension ya pgvector, na dashboard ya Next.js. mem0 ni safu ya kumbukumbu kwa ajili ya mawakala (agents). Unatuma mazungumzo kwake, modeli ya lugha huchota ukweli wa kudumu kutoka kwenye mazungumzo hayo, na ukweli huo huhifadhiwa kama vekta ili swali la baadaye liweze kuchota yale yanayohusika.
Tenga takriban 1 GB ya kumbukumbu ya resident kwa ajili ya container hizo tatu, na 3 hadi 4 GB ya diski pindi images zitakapojengwa. VPS ya 2 GB huendesha haya kwa urahisi wakati modeli ya lugha inapokuwa mahali pengine. Modeli inapoendeshwa kwenye mashine hiyo hiyo kupitia Ollama, modeli hiyo hutawala kila kitu kingine: modeli ya 8B iliyopunguzwa (quantised) hadi bits 4 huhitaji takriban 6 GB peke yake, kwa hivyo ujenzi wa ndani kabisa huanzia 8 GB.
Usichukulie takwimu hizo kutoka kwenye chapisho la blogu, ikiwemo hili. Pima stack uliyojenga wewe mwenyewe.
docker compose ps
docker stats --no-stream
docker system df -vdocker stats huchapisha kumbukumbu ya resident kwa kila container. docker system df -v huchapisha diski inayoshikiliwa na kila image na kila volume.
Hali ya utulivu (steady state) si kilele cha matumizi. docker compose up -d --build huandaa (compile) dashboard ya Next.js, na ujenzi huo wa Node ndio wakati wenye njaa zaidi katika usakinishaji mzima. Kwenye VPS ya 1 GB, kernel out-of-memory killer huizuia na ujenzi huishia na exit code 137. Thibitisha sababu kabla ya kuanza kutafuta hitilafu ya Docker:
dmesg -T | grep -i "killed process"Ikiwa seva inaonekana kama mashine nyingi mno kwa unachohitaji, chaguzi ndogo ni halisi. hifadhi ya kumbukumbu ya wakala wa ndani bila seva yoyote na kumbukumbu inayokaa ndani ya Claude Code yenyewe zote huruka database. Rudi hapa wakati mawakala kadhaa, au mashine kadhaa, zinahitaji kusoma kumbukumbu zile zile.
Je, ninahitaji Neo4j kwa ajili ya mem0 graph memory?
Hapana. Ikiwa mwongozo unakuambia uongeze container ya Neo4j, mwongozo huo umepitwa na wakati.
Graph memory katika mem0 zamani ilimaanisha database ya nje ya graph, iliyosanidiwa chini ya ufunguo wa graph_store huku enable_graph ikiwa imewekwa kuwa true. Algorithm mpya ya kumbukumbu, iliyosafirishwa mnamo Aprili 2026, iliondoa funguo zote mbili kutoka kwa SDK ya open source. Uchimbaji wa entity sasa unafanyika ndani ya njia ya kawaida ya add, na entities huandikwa kwenye mkusanyiko wa pili wa pgvector uliopewa jina la mkusanyiko wako mkuu na kuongezewa _entities mwishoni. Hakuna hatua ya usanidi: mkusanyiko huo hutengenezwa wakati wa matumizi ya kwanza, kwa hivyo uunganishaji wa entity uliojengewa ndani huanza kufanya kazi kwenye wito wa add unaofuata.
Kuacha graph store huokoa container ya JVM, heap yake, na mamia kadhaa ya megabytes ya image. Kwenye VPS ya 2 GB, hiyo ndiyo tofauti kati ya kufanya kazi vizuri na kutumia swapping.
Hivi ndivyo unavyopoteza, kwa ufafanuzi rahisi. Matokeo ya utafutaji zamani yalikuwa na uwanja wa relations unaoorodhesha edges kati ya entities. Uwanja huo haupo tena. Mechi za entity sasa huongeza nafasi ya kumbukumbu katika alama iliyojumuishwa, na hakuna muundo unaoweza kuupitia. Ikiwa programu yako ilikuwa ikitembea kwenye mahusiano hayo, mem0 haishikilii tena, na unapaswa kuweka database yako ya graph nje ya mem0, inayolishwa na msimbo wako mwenyewe.
Faili la compose lililopo kwenye repo ni la maendeleo
server/docker-compose.yaml inatangaza name: mem0-dev, na inamaanisha hivyo. Isome kabla ya kuiendesha, kwa sababu kuna mambo matano ndani yake ambayo hayafai kwa seva.
- Inajenga kutoka
server/dev.Dockerfilena ku-mount checkout yako juu ya image kwa kutumia.:/app, kwa hivyo container inaendesha chochote kilichopo kwenye saraka hiyo badala ya kile ulichokijenga. - Amri yake ni
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. Hiyo inasakinisha upyamem0aikutoka PyPI kila inapoanza, kwa hivyo toleo ambalo seva yako inaendesha linaweza kubadilika wakati wa kuanzisha upya (restart) ambalo hukuliona kama ni upgrade. - Hatua hiyo ya pip inamaanisha kuwa kuanzisha upya bila mtandao wa nje kutafeli kabla ya uvicorn kuwaka. Seva yako ya kumbukumbu itakuwa chini kwa sababu PyPI haikufikika.
--reloadinawasha kichunguzi cha faili cha uvicorn. Kipo ili kuanzisha upya mchakato unapohariri msimbo, na kinatumia kumbukumbu na mchakato wa pili bila kufanya kitu chochote cha maana katika uzalishaji (production).Dockerfileya uzalishaji inabeba--reloadkatikaCMDyake pia, kwa hivyo unabatilisha amri hiyo kwa njia yoyote ile.- Port zilizochapishwa ni
"8888:8000","8432:5432"na"3000:3000". Port iliyochapishwa bila anwani mbele yake inajifunga kwenye0.0.0.0, kwa hivyo Postgres inajibu mtandao wa umma kwenye 8432 mara tu stack inapoanza.
Hoja hiyo ya mwisho inastahili onyo lake yenyewe. Docker inachapisha port kwa kuandika sheria zake mbele ya mnyororo ambao ufw inasimamia, kwa hivyo ufw deny 8432 haifungi port ya container iliyochapishwa. Docker kuchapisha port moja kwa moja kupita ufw inaelezea sheria zinazohusika.
Faili ya compose kwa seva halisi
Fanya kazi ndani ya server/, weka init-db.sh mahali pake, na ubadilishe docker-compose.yaml na hii.
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: bridgeMabadiliko matano ni muhimu hapa, na kila moja lina sababu yake.
Kila ingizo la ports huanza na 127.0.0.1, ili kernel ikubali miunganisho hiyo kutoka kwa seva yenyewe pekee. Kila kitu kutoka nje hufika kupitia reverse proxy, ambayo ndiyo pekee inayoshikilia cheti.
Postgres haina block ya ports kabisa. Container ya mem0 huifikia kupitia mem0_network kwa kutumia jina la huduma, kwa hivyo kuchapisha 8432 hakukupi faida yoyote na kunagharimu port iliyo wazi. Tumia docker compose exec postgres psql -U postgres wakati unahitaji shell.
Historia huhama kutoka kwa bind mount ya ./history kwenda kwa named volume. Bind mount hufunga data kwenye path moja na uid moja kwenye host hii, wakati named volume ni kitu ambacho Docker inaweza kukipiga snapshot na kukihamisha. Named volumes dhidi ya bind mounts inaelezea wakati ambapo kila moja inafaa.
Amri huondoa --reload na kuhifadhi alembic upgrade head. Hifadhi hatua hiyo ya uhamiaji. Bila hiyo, app huwaka dhidi ya database isiyo na tables, na kila ombi hushindwa kwenye query ya kwanza.
NEXT_PUBLIC_API_URL ndiyo URL ambayo browser yako huita, kwa hivyo lazima iwe anwani ya umma ya HTTPS na si http://mem0:8000. Next.js huweka thamani za NEXT_PUBLIC_ wakati wa build, lakini image ya dashboard hii huweka placeholder badala yake, na entrypoint yake hubadilisha thamani halisi ya container wakati container inapoanza. Kwa hivyo, kuibadilisha kunahitaji docker compose up -d mem0-dashboard, ambayo hutengeneza upya container, na si rebuild. docker compose restart mem0-dashboard hutumia tena container ya zamani, ambayo faili zake tayari zina thamani ya zamani, na dashboard huendelea kuita host isiyo sahihi.
Siri huhifadhiwa kwenye .env, na .env haipaswi kufikiwa na Internet
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 .envSanidi POSTGRES_PASSWORD, JWT_SECRET na ADMIN_API_KEY. Acha AUTH_DISABLED=false kama ilivyo. Jina la flag hii linaeleza wazi kazi yake: ikiwa imewashwa, seva hutoa kumbukumbu zake zote kwa yeyote anayeweza kufikia port hiyo. Sanidi MEM0_TELEMETRY=false ikiwa hutaki tukio la onboarding litumwe kwenye seva ya mbali (upstream).
ADMIN_API_KEY inalinganishwa na header ya X-API-Key kwa kutumia secrets.compare_digest, na zikilingana, mfumo huruka hatua ya kutafuta ufunguo (key) kwenye database: ombi hilo huendeshwa kama mtumiaji wa kwanza aliyewahi kuundwa kwenye seva. Hii ni credential ya root kwa API nzima. Ichukulie kama hivyo: usiihifadhi kwenye shell history, usiweke kwenye git, na usiiweke kwenye prompt yoyote. Kutunga faili za env na mahali siri zinapovuja na kuepusha API keys kwenye muktadha wa agent zote zinahusika moja kwa moja, kwa sababu wanaopiga simu kwenye seva hii ni agents.
Thamani zinazopakiwa kutoka env_file hukaa kwenye mazingira ya container, na docker inspect huzichapisha zote. Mtu yeyote aliye kwenye kundi la docker anaweza kuzisoma, na mtu yeyote aliye kwenye kundi la docker ana mamlaka sawa na root kwenye host.
Weka TLS mbele ya API badala ya kufungua 8888
API inajibu kwenye 127.0.0.1:8888 na dashboard kwenye 127.0.0.1:3000. nginx inamalizia TLS (transport layer security) kwenye 443 na kusambaza maombi kwa zote mbili.
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;
}
}Nambari ya kivinjari ya dashboard inaita kila njia ya API katika muundo huo kwenye NEXT_PUBLIC_API_URL, ikijumuisha /entities na /requests. Ukiacha moja, nginx itapeleka wito huo kwa Next.js, kwa hivyo ukurasa wa dashboard unaohitaji data hiyo utapata 404 badala ya data.
proxy_read_timeout ni muhimu zaidi kuliko inavyoonekana. Wito wa kuongeza (add call) husubiri wakati lugha ya mfano (language model) inasoma mazungumzo na kutoa ukweli. Mfano wa 8B wa ndani kwenye CPU mara nyingi huchukua muda mrefu kuliko muda chaguo-msingi wa nginx wa sekunde 60, na kisha mpigaji huona 504 Gateway Time-out wakati mfano bado unafanya kazi na kumbukumbu bado inaandikwa. Unapata kumbukumbu ambayo uliambiwa imeshindwa.
Funga mengine kwa sera ya ufw ya kukataa kila kitu kwa chaguo-msingi, ukiacha 22, 80 na 443 wazi. Toa cheti kwa certbot kwenye Ubuntu 24.04 nyuma ya nginx. Port 80 lazima ibaki inafikika kwa sababu mtiririko huo wa kazi hutumia changamoto ya HTTP-01, ambayo Let's Encrypt huiendesha kwenye port 80 pekee, wakati wa utoaji na tena wakati wa kila ufanyaji upya. Kuweka 80 imefungwa inamaanisha kubadili hadi changamoto ya DNS-01. Ikiwa seva tayari inahudumia programu nyingine kwa Traefik inayoelekeza programu kadhaa za Compose, ongeza mem0 kwenye router hiyo badala ya kusakinisha proxy ya pili.
Jaribio la moshi: ongeza kumbukumbu moja na uisome tena
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"}'Jibu sahihi ni kitu cha JSON chenye orodha ya results, na kila ingizo lina id, maandishi ya memory yaliyotolewa, na "event": "ADD". Algorithm ya sasa inarejesha matukio ya ADD pekee. Matukio ya UPDATE na DELETE yaliondolewa, kwa hivyo kutokuwepo kwao si hitilafu.
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}'Ukweli kuhusu Postgres 17 unapaswa kurejea na alama (score). Pitisha kitambulishi ndani ya filters, kama inavyoonyeshwa. user_id ya kiwango cha juu bado inafanya kazi, na seva huweka kumbukumbu ya Top-level user_id in /search is deprecated. Use filters={...} instead. kila unapoitumia.
Safisha data uliyotumia ili data ya majaribio isichafue utafutaji halisi:
curl -sS -X DELETE "http://127.0.0.1:8888/memories?user_id=smoke" \
-H "X-API-Key: $MEM0_KEY"Ikiwa utafutaji utarejesha safu chache kuliko ulivyotarajia, kagua mipangilio chaguo-msingi kabla ya kulaumu mfumo wa urejeshaji. Katika toleo la sasa, top_k ina thamani chaguo-msingi ya 20, ikishuka kutoka 100, na threshold ina thamani chaguo-msingi ya 0.1 badala ya kutokuwa na thamani, kwa hivyo mechi dhaifu sasa huchujwa kiotomatiki. Mara tu hii inapofanya kazi kupitia curl, endpoints zilezile ndizo unazounganisha kwenye agent, iwe moja kwa moja au kupitia seva ya MCP inayofanya kazi kwenye VPS hiyo hiyo.
Endesha mem0 bila ufunguo wa OpenAI hata kidogo
Anza na kizuizi, kwa sababu utakutana nacho katika dakika tano za kwanza. Image ya seva inakuja na seti maalum ya maktaba za watoa huduma, na /configure hukataa chochote kilicho nje ya hizo:
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.Huna haja ya kujenga upya chochote. Ollama hutoa API inayooana na OpenAI kwenye /v1, ikijumuisha /v1/chat/completions na /v1/embeddings, na mtoa huduma wa openai wa mem0 hukubali openai_base_url. Elekeza ufunguo huo kwenye Ollama na ukaguzi wa ndani utapita, kwa sababu mtoa huduma huyo ni openai kweli. Anwani pekee ndiyo inayobadilika.
Ongeza Ollama kwenye mradi huo huo wa Compose:
ollama:
image: ollama/ollama
restart: unless-stopped
networks: [mem0_network]
ports:
- "127.0.0.1:11434:11434"
volumes:
- ollama_models:/root/.ollamaOngeza ollama_models: chini ya ufunguo mkuu wa volumes:, kisha vuta model moja ya chat na model moja ya embedding:
docker compose up -d ollama
docker compose exec ollama ollama pull llama3.1:8b
docker compose exec ollama ollama pull nomic-embed-textIkiwa Ollama tayari inaendeshwa kwenye host kama systemd unit, kama ilivyo katika kuendesha Ollama moja kwa moja kwenye VPS, usielekeze container kwenye 127.0.0.1:11434. Ndani ya container ya mem0, 127.0.0.1 ni container ya mem0 yenyewe. Ipe huduma ya mem0 extra_hosts: ["host.docker.internal:host-gateway"], weka Environment="OLLAMA_HOST=0.0.0.0:11434" katika systemd drop-in ili Ollama isikilize kwenye anwani ambayo bridge inaweza kuifikia, na uweke port 11434 ikiwa imefungwa kwenye firewall.
Uliza model ukubwa wake wa embedding kabla ya kusanidi chochote
Hatua hii moja huamua kama utafutaji (retrieval) utafanya kazi kabisa.
Hifadhi ya pgvector ya mem0 hutengeneza jedwali lake kwa upana maalum wa vector, vector vector(1536), kwa sababu embedding_model_dims hutumia 1536 kama chaguo-msingi, ambalo ni upana wa text-embedding-3-small ya OpenAI. nomic-embed-text hurejesha thamani 768. Hakuna kitu ndani ya mem0 kinacholinganisha namba hizo mbili, kwa hivyo kutolingana huko hujitokeza kutoka Postgres wakati wa insert ya kwanza:
expected 1536 dimensions, not 768Usiweke imani yako kwenye namba iliyo katika aya hii pia. Uliza model:
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']))"Hiyo itachapisha upana ambao mkusanyiko wako lazima utumie. Andika usanidi kwenye faili, kwa sababu kubandika nenosiri la Postgres kupitia shell quoting ndiyo njia ya makosa ya uchapaji kuingia kwenye 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"Wito wa pili husoma usanidi huo tena, ambao ni ukaguzi kwamba uandishi umefanikiwa. Kisha rudia jaribio la awali la smoke test.
Maelezo manne katika JSON hiyo si ya wazi, na kila moja huvunja kitu fulani ukikosea.
api_key ni string ya ollama, na Ollama hupuuza thamani yake. Haiwezi kuwa tupu, kwa sababu maktaba ya mteja wa OpenAI hutoa hitilafu kabla ya ombi lolote kutoka kwenye mchakato wakati hakuna ufunguo uliowekwa. String yoyote isiyo tupu itafanya kazi.
embedding_model_dims huwekwa kwenye vector store, na kwa makusudi hakuna embedding_dims kwenye embedder. mem0 hutuma parameter ya dimensions ya OpenAI pale tu unapoweka embedding_dims, na backend ambazo hazitekelezi Matryoshka truncation hukataa parameter hiyo moja kwa moja. Weka upana pale jedwali linapoundwa, na uache embedder peke yake.
collection_name ni mpya. mem0 hutengeneza jedwali lake kwa CREATE TABLE IF NOT EXISTS, kwa hivyo kuelekeza upana tofauti kwenye mkusanyiko uliopo hakufanyi chochote: safu ya zamani ya vector(1536) inabaki, na kila insert inafeli. Mabadiliko ya upana yanahitaji jina jipya la mkusanyiko, au ufute jedwali la zamani kwa mkono.
Host katika openai_base_url ni jina la huduma ya Compose ollama, si localhost. Container hutatua majina ya kila mmoja kwa kutumia jina la huduma kwenye mtandao wao wa pamoja.
Gharama ya njia ya ndani kabisa (fully local)
Kuwa mkweli kwako mwenyewe kuhusu ubora. Alama za benchmark za mem0 zinatoka kwenye jukwaa lao linalosimamiwa, ambalo README inasema linajumuisha uboreshaji wa umiliki ambao haupatikani kwenye SDK ya open source, na huendeshwa kwenye stack ya model ambayo haijatajwa. Karatasi ya utafiti iliyo nyuma ya matokeo ya awali ya LOCOMO iliendesha kila wito wa model kwenye GPT-4o-mini, model inayohudumiwa. Vyovyote vile, chukulia alama hizo kama ukomo wa juu badala ya utabiri wa model ya 8B kwenye VPS yako. Model ndogo huandika ukweli usio na uhakika, na wakati mwingine hurejesha sentensi badala ya JSON iliyoombwa, jambo linaloonekana kama wito wa add unaorejesha orodha tupu ya results bila hitilafu.
Kasi ndiyo gharama nyingine. Uchimbaji wa data kwa kutumia CPU pekee huchukua sekunde kwa kila wito wa add, na kila ujumbe unaohifadhi hulipia gharama hiyo. Model inayozunguka nje ya JSON iliyoombwa hufanya hali hiyo kuwa mbaya zaidi, kwa hivyo kuzuia jibu kwa num_predict huweka ukomo wa muda ambao wito mmoja wa add unaweza kuendesha. Ikiwa latency hiyo ni muhimu, VPS yenye GPU iliyounganishwa ndiyo suluhisho la kweli. Kuongeza cores zaidi za CPU kwenye model ya 8B husaidia kidogo sana kuliko watu wanavyotarajia. Kubadilisha model ni njia rahisi zaidi kuliko kubadilisha mashine, na Nemotron 3.5 Lightning kwenye VPS inakupa tag ya kuvuta, RAM inayohitaji, na kama CPU pekee inatosha kwa matumizi yako.
Kanuni moja inabaki bila kujali unachochagua: usichanganye kamwe model za embedding ndani ya mkusanyiko mmoja. Model mbili tofauti ambazo kwa bahati zina upana sawa huzalisha vector ambazo haziwezi kulinganishwa. Insert hufanikiwa, utafutaji hurejesha safu, na safu hizo huwa si sahihi, bila kitu chochote kuripoti hitilafu.
Hifadhi rudufu: kuna hifadhidata mbili, si moja
Kosa la kawaida katika hifadhi rudufu ya mem0 ni kutoa nakala ya hifadhidata moja pekee. init-db.sh hutengeneza mem0_app sambamba na hifadhidata ya kawaida ya postgres, na hizi huhifadhi vitu tofauti. Hifadhidata ya postgres huhifadhi mikusanyiko ya pgvector, ambayo ndiyo kumbukumbu. mem0_app huhifadhi watumiaji, vipindi (sessions), API keys na kumbukumbu za maombi (request logs). Kila programu inayojiendesha yenyewe hugawa hali yake (state) kwa njia yake, ndiyo maana seva mbili za picha zinazofanya kazi sawa bado zinahitaji amri tofauti za hifadhi rudufu; hivyo soma kile ambacho programu yako huhifadhi kabla ya kuamini nakala ya dump. Katika mwisho wa wigo huo kuna kitu kama maktaba ya Jellyfin iliyojengwa upya kama duka la video la miaka ya 90, ambayo husoma katalogi yake yote kutoka huduma nyingine na hivyo inahitaji nakala ya usanidi wake tu, wakati mem0 inahitaji hifadhidata zote mbili la sivyo urejeshaji hautafaa.
Ukirejesha postgres pekee, kumbukumbu zitarudi lakini kila akaunti na API key itakuwa imepotea, hivyo hakuna kitakachoweza kuthibitisha utambulisho ili kuzisoma. Toa nakala ya zote mbili, pamoja na roles, kwa amri moja:
docker compose exec -T postgres pg_dumpall -U postgres --clean \
| gzip > "mem0-$(date +%F).sql.gz"Volyumu ya historia ni tofauti na Postgres na inahitaji nakala yake yenyewe:
docker run --rm -v mem0_mem0_history:/data -v "$PWD:/backup" \
alpine tar czf /backup/mem0-history.tgz -C /data .Docker huweka viambishi awali (prefixes) kwenye majina ya volyumu kwa kutumia jina la mradi, kwa hivyo thibitisha jina lako kwa docker volume ls kabla ya kudhani ni mem0_mem0_history.
Rejesha kwenye kontena la majaribio (scratch container) na uhakiki idadi ya safu (row counts) kabla ya kuamini chochote:
gunzip -c mem0-2026-08-03.sql.gz \
| docker compose exec -T postgres psql -U postgres -d postgresHifadhi rudufu ambayo hujawahi kuirejesha ni kubahatisha tu. Pindi nakala za dump zitakapokuwa sahihi, zihamishe kutoka kwenye seva hiyo kwa kutumia restic snapshots kwenda kwenye hifadhi ya nje, kwa sababu hifadhi rudufu inayokaa kwenye seva inayolindwa haitoi ulinzi wowote.
Njia za kufeli na ujumbe kamili utakaouona
{"detail":"Authentication required. Provide a Bearer token or X-API-Key header."} inamaanisha kuwa kichwa cha habari (header) hakipo au kimeandikwa vibaya. Jina lake ni X-API-Key, na curl hutuma majina ya header kama yalivyo.
{"detail":"At least one identifier (user_id, agent_id, run_id) is required."} kwenye kitendo cha add inamaanisha ombi halikuwa na yoyote kati ya hayo. Kumbukumbu lazima iwe na wigo (scope) kwa kitu fulani, kwa sababu utafutaji huchuja kwa kutumia sehemu hizo hasa.
LLM provider 'ollama' is not bundled in this image pamoja na HTTP 400 inamaanisha umetuma "provider": "ollama". Tumia "provider": "openai" huku openai_base_url ikielekezwa kwenye Ollama.
expected 1536 dimensions, not 768 kutoka Postgres inamaanisha kuwa mkusanyiko (collection) uliundwa kwa upana mmoja na embedder inarudisha mwingine. Weka embedding_model_dims kwenye vector store na utumie collection_name mpya.
Utafutaji unarudisha safu zisizo na maana baada ya kubadilisha modeli, bila hitilafu yoyote. Upana bado unalingana, kwa hivyo hifadhidata inafanya kazi, lakini modeli mbili huweka sentensi moja katika nafasi tofauti. Anzisha mkusanyiko mpya na uongeze data upya.
Connection refused katika logi za mem0 wakati wa kufikia Ollama kwa kawaida inamaanisha 127.0.0.1 katika openai_base_url. Ndani ya kontena, anwani hiyo ni kontena lenyewe. Tumia jina la huduma, au host gateway wakati Ollama inafanya kazi kwenye host.
504 Gateway Time-out kutoka nginx kwenye kitendo cha add inamaanisha modeli ilichukua muda mrefu zaidi ya proxy_read_timeout. Ongeza muda huo, na uangalie kama kumbukumbu iliandikwa hata hivyo kabla ya kujaribu ombi hilo tena.
exit code 137 wakati wa docker compose up --build inamaanisha mchakato uliua kwa SIGKILL, kwa sababu signal mbaya N huripotiwa kama 128 + N na SIGKILL ni signal 9. Wakati dashibodi inajengwa kwenye VPS ndogo, mhusika mkuu mara nyingi ni out-of-memory killer, kwa hivyo endesha ukaguzi wa dmesg kutoka sehemu ya kwanza kabla ya kuchukua hatua. Ikiwa hiyo inaonyesha mchakato uliouawa, ongeza swap, au jenga image kwenye mashine kubwa kisha uisukume kwenye registry.
error: port 3000 is already in use inatoka kwenye target ya make up ya repo, ambayo inakataa kuanza wakati 3000 au 8888 zinatumiwa na huduma nyingine. Tafuta mmiliki wa port hizo kwa kutumia lsof -iTCP:3000 -sTCP:LISTEN.
FAQ
Je, bado nahitaji Neo4j ili kuendesha mem0 na graph memory?
Hapana. Algorithm mpya ya kumbukumbu, iliyosafirishwa mnamo Aprili 2026, imeondoa funguo za usanidi za graph_store na enable_graph kutoka kwenye SDK ya chanzo huria. Uchimbaji wa entity sasa unafanyika wakati wa operesheni ya kawaida ya kuongeza (add) na kuandika kwenye mkusanyiko wa pili wa pgvector unaoitwa <collection_name>_entities, kwa hivyo hakuna database ya graph ya nje, hakuna container ya ziada, na hakuna hatua ya usanidi. Hasara yake ni kwamba uwanja wa relations kwenye matokeo ya utafutaji haupo tena. Entities sasa huongeza kiwango cha umuhimu wa kumbukumbu badala ya kukupa viungo (edges) vya kupitia, kwa hivyo programu iliyokuwa ikitumia mahusiano hayo inahitaji hifadhi yake ya graph nje ya mem0.
Je, ni VPS ndogo kiasi gani inayoweza kuendesha seva ya mem0 iliyojihostia?
Ikiwa mfano wa lugha (language model) umewekwa mahali pengine, 2 GB ya RAM na takriban 4 GB ya diski iliyo wazi inatosha kwa container ya API, Postgres, na dashibodi. Wakati mgumu ni ujenzi wa kwanza, kwa sababu kukusanya (compiling) dashibodi ya Next.js hutumia kumbukumbu nyingi kuliko kuiendesha, na mashine ya 1 GB itapata ujenzi wake kukatishwa na exit code 137. Ikiwa Ollama inaendeshwa kwenye seva hiyo hiyo, panga nafasi kwa ajili ya model: model ya 8B yenye 4-bit quantisation inahitaji takriban 6 GB yenyewe, kwa hivyo panga kuwa na 8 GB.
Je, ninaweza kuendesha mem0 bila ufunguo wa OpenAI API?
Ndiyo, kupitia endpoint ya Ollama inayooana na OpenAI. Kuweka "provider": "ollama" kutafeli, kwa sababu image ya seva inajumuisha tu maktaba za openai, anthropic na gemini na inarudisha HTTP 400. Badala yake, weka "provider": "openai" na uweke "openai_base_url": "http://ollama:11434/v1" na api_key yoyote isiyo tupu, kwa ajili ya llm na embedder. Ollama hupuuza ufunguo huo, na ukaguzi wa mtoa huduma uliounganishwa hufaulu kwa sababu mtoa huduma kwa kweli ni openai.
Kwa nini mem0 hairudishi matokeo baada ya kubadili kwenda kwenye model ya embedding ya ndani?
Kwa sababu jedwali la pgvector liliundwa kwa upana uliowekwa. embedding_model_dims ina default ya 1536, nomic-embed-text inarudisha 768, na Postgres inakataa kuingiza data (insert) kwa expected 1536 dimensions, not 768. mem0 huunda jedwali kwa CREATE TABLE IF NOT EXISTS, kwa hivyo kubadilisha namba pekee hakufanyi chochote kwenye mkusanyiko uliopo. Weka embedding_model_dims kwenye upana halisi wa model yako, thibitisha upana huo kwa kuita /v1/embeddings na kuhesabu thamani inazozirudisha, na upe hifadhi ya vector collection_name mpya wakati huo huo.