Self-hosting di mem0 su VPS: RAM e configurazione
Scopri quanta RAM richiede davvero mem0: circa 1 GB senza modello locale, almeno 8 GB con Ollama, più Compose, localhost e TLS.
Quanto costa davvero in RAM eseguire mem0 in self-hosting su un VPS
Eseguire mem0 in self-hosting significa avviare tre container: il server FastAPI per la memoria, Postgres con l'estensione pgvector e una dashboard Next.js. mem0 è un livello di memoria per gli agenti. Si invia una conversazione al servizio, un modello linguistico estrae i fatti persistenti da quella conversazione e tali fatti vengono memorizzati come vettori, in modo che una query successiva possa recuperare quelli pertinenti.
Considerare circa 1 GB di memoria residente per i tre container e da 3 a 4 GB di spazio su disco dopo la creazione delle immagini. Un VPS da 2 GB esegue questa configurazione senza problemi quando il modello linguistico si trova altrove. Se il modello viene eseguito sullo stesso server tramite Ollama, il modello richiede molte più risorse di tutto il resto: un modello 8B quantizzato a 4 bit richiede da solo circa 6 GB, quindi una configurazione completamente locale richiede almeno 8 GB.
Non usare queste cifre come riferimento tratto da un post di un blog, incluso questo. Misura lo stack che hai effettivamente creato.
docker compose ps
docker stats --no-stream
docker system df -vdocker stats stampa la memoria residente per container. docker system df -v stampa lo spazio su disco occupato da ogni immagine e da ogni volume.
L'utilizzo a regime non corrisponde al picco. docker compose up -d --build compila la dashboard Next.js e questa compilazione Node rappresenta il momento con il maggiore consumo di memoria dell'intera installazione. Su un VPS da 1 GB, il kernel interrompe il processo tramite l'out-of-memory killer e la compilazione termina con exit code 137. Conferma la causa prima di cercare un bug di Docker:
dmesg -T | grep -i "killed process"Se un server ti sembra un'infrastruttura eccessiva per le tue esigenze, esistono opzioni più semplici. un archivio locale della memoria degli agenti senza alcun server e la memoria gestita direttamente da Claude Code evitano entrambi il database. Torna a questa soluzione quando più agenti o più macchine devono leggere le stesse memorie.
Servono Neo4j e la memoria a grafo di mem0?
No. Se una guida indica di aggiungere un container Neo4j, è più vecchia del codice attuale.
In precedenza, la memoria a grafo in mem0 indicava un database a grafo esterno, configurato con una chiave graph_store e con enable_graph impostato su true. Il nuovo algoritmo di memoria, rilasciato ad aprile 2026, ha rimosso entrambe le chiavi dall'SDK open source. L'estrazione delle entità viene ora eseguita durante il normale percorso di aggiunta e le entità vengono scritte in una seconda raccolta pgvector, il cui nome è quello della raccolta principale con _entities aggiunto alla fine. Non è necessaria alcuna configurazione: la raccolta viene creata al primo utilizzo, quindi il collegamento integrato delle entità inizia a funzionare alla chiamata add successiva.
La rimozione dell'archivio a grafo elimina un container JVM, la relativa memoria heap e diverse centinaia di megabyte di immagine. Su un VPS con 2 GB, può fare la differenza tra un sistema operativo e uno che usa la memoria di swap.
Ecco cosa si perde, in modo diretto. In precedenza, i risultati della ricerca includevano un campo relations che elencava gli archi tra le entità. Quel campo non esiste più. Le corrispondenze tra entità ora aumentano la posizione di una memoria nel punteggio combinato e non esiste alcuna struttura attraversabile. Se l'applicazione seguiva queste relazioni, mem0 non le conserva più. È quindi necessario gestire un database a grafo autonomo, esterno a mem0, alimentato dal proprio codice.
Il file compose nel repository è una configurazione compose per lo sviluppo
server/docker-compose.yaml dichiara name: mem0-dev e lo fa realmente. Leggilo prima di eseguirlo, perché contiene cinque impostazioni errate per un server.
- Esegue la build da
server/dev.Dockerfilee monta il checkout sopra l'immagine con.:/app. Il container esegue quindi il contenuto presente in quella directory, non quello incluso nell'immagine appena creata. - Il comando è
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. A ogni avvio reinstallamem0aida PyPI. Di conseguenza, la versione eseguita dal server può cambiare durante un riavvio che non consideravi un aggiornamento. - Lo stesso passaggio con pip implica che un riavvio senza accesso alla rete in uscita fallisca prima dell'avvio di uvicorn. Il server della memoria rimane quindi inattivo perché PyPI non è raggiungibile.
--reloadavvia il file watcher di uvicorn. Serve a riavviare il processo quando modifichi il codice, ma in produzione consuma memoria e mantiene un secondo processo senza svolgere alcuna funzione utile. La configurazione di produzioneDockerfileinclude a sua volta--reloadnel relativoCMD, quindi in ogni caso devi sovrascrivere il comando.- Le porte pubblicate sono
"8888:8000","8432:5432"e"3000:3000". Una porta pubblicata senza un indirizzo davanti viene associata a0.0.0.0. Di conseguenza, Postgres risponde su 8432 dalla rete Internet pubblica non appena lo stack viene avviato.
Quest'ultimo punto richiede un avviso specifico. Docker pubblica una porta inserendo le proprie regole prima della catena gestita da ufw. Pertanto, ufw deny 8432 non chiude una porta pubblicata dal container. Pubblicazione diretta delle porte Docker oltre ufw illustra le regole coinvolte.
Un file Compose per un server reale
Lavorare all'interno di server/, mantenere init-db.sh nella posizione attuale e sostituire docker-compose.yaml con questo contenuto.
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: bridgeQui contano cinque modifiche, ognuna con una motivazione.
Ogni voce ports inizia con 127.0.0.1, quindi il kernel accetta queste connessioni soltanto dal server stesso. Tutto il traffico dall'esterno passa attraverso il reverse proxy, che è l'unico componente in possesso di un certificato.
Postgres non contiene alcun blocco ports. Il container mem0 lo raggiunge tramite mem0_network usando il nome del servizio, quindi pubblicare 8432 non offre alcun vantaggio e lascia invece una porta aperta. Usare docker compose exec postgres psql -U postgres quando serve una shell.
La cronologia passa dal bind mount ./history a un volume denominato. Un bind mount lega i dati a un solo percorso e a un solo uid su questo host, mentre un volume denominato è un oggetto che Docker può sottoporre a snapshot e spostare. Volumi denominati e bind mount descrive i casi in cui usare l'una o l'altra soluzione.
Il comando rimuove --reload e mantiene alembic upgrade head. Mantenere questo passaggio della migrazione. Senza di esso, l'applicazione si avvia con un database privo di tabelle e ogni richiesta fallisce alla prima query.
NEXT_PUBLIC_API_URL è l'URL che il browser richiama, quindi deve essere l'indirizzo HTTPS pubblico e non http://mem0:8000. Next.js incorpora i valori NEXT_PUBLIC_ durante la build, ma l'immagine di questa dashboard incorpora invece un valore segnaposto e il suo entrypoint lo sostituisce con il valore effettivo del container all'avvio. Per modificarlo è quindi necessario docker compose up -d mem0-dashboard, che ricrea il container, senza eseguire una nuova build. docker compose restart mem0-dashboard riutilizza il vecchio container, i cui file contengono ancora il valore precedente, e la dashboard continua a richiamare l'host errato.
I secreti risiedono in .env, che non deve essere esposto a 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 .envImposta POSTGRES_PASSWORD, JWT_SECRET e ADMIN_API_KEY. Lascia AUTH_DISABLED=false. Il nome descrive correttamente il comportamento di questo flag: quando è attivo, il server consegna tutta la memoria in suo possesso a chiunque possa raggiungere la porta. Imposta MEM0_TELEMETRY=false se non vuoi che l'evento di onboarding venga inviato al servizio upstream.
ADMIN_API_KEY viene confrontato con l'header X-API-Key tramite secrets.compare_digest. In caso di corrispondenza, la ricerca della chiave nel database viene completamente saltata: la richiesta viene quindi eseguita come il primo utente creato sul server. È una credenziale root per l'intera API. Trattala come tale: niente cronologia della shell, niente git e niente copia-incolla in un prompt. File env di Compose e dove i secret possono fuoriuscire e tenere le chiavi API fuori dal contesto di un agent si applicano direttamente, perché i client di questo server sono agent.
I valori caricati da env_file risiedono nell'ambiente del container e docker inspect li stampa integralmente. Chiunque appartenga al gruppo docker può leggerli e chiunque appartenga al gruppo docker è di fatto root sull'host.
Posizionare TLS davanti all’API invece di esporre la porta 8888
L’API risponde su 127.0.0.1:8888 e la dashboard su 127.0.0.1:3000. nginx termina TLS (sicurezza del livello di trasporto) sulla porta 443 e inoltra le richieste a entrambi.
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;
}
}Il codice JavaScript della dashboard richiama ogni percorso API con questo schema su NEXT_PUBLIC_API_URL, inclusi /entities e /requests. Se ne ometti uno, nginx inoltra quella chiamata a Next.js. Di conseguenza, la pagina della dashboard che ne ha bisogno riceve un errore 404 invece dei dati.
proxy_read_timeout è più importante di quanto sembri. Una chiamata di aggiunta resta bloccata mentre il modello linguistico legge la conversazione ed estrae i fatti. Un modello locale da 8B eseguito sulla CPU supera regolarmente il timeout predefinito di 60 secondi di nginx. Il chiamante vede quindi 504 Gateway Time-out mentre il modello sta ancora lavorando e la memoria viene comunque salvata. Il risultato è una memoria che risulta fallita anche se è stata scritta.
Chiudi tutte le altre porte con una policy ufw predefinita con deny, lasciando aperte 22, 80 e 443. Emetti il certificato con certbot su Ubuntu 24.04 dietro nginx. La porta 80 deve rimanere raggiungibile perché questa procedura usa la challenge HTTP-01, che Let's Encrypt esegue solo sulla porta 80, sia durante l’emissione sia a ogni rinnovo. Se la porta 80 resta chiusa, devi passare a una challenge DNS-01. Se il server espone già altre applicazioni tramite Traefik che instrada diverse applicazioni Compose, aggiungi mem0 a quel router invece di installare un secondo proxy.
Test di base: aggiungere una memoria e rileggerla
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"}'Una risposta corretta è un oggetto JSON con un elenco results. Ogni elemento contiene un id, il testo memory estratto e "event": "ADD". L'algoritmo attuale restituisce soltanto eventi ADD. Gli eventi UPDATE e DELETE sono stati rimossi, quindi la loro assenza non indica un problema.
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}'Il dato su Postgres 17 dovrebbe essere restituito con un punteggio. Passa l'identificatore all'interno di filters, come mostrato. Un user_id al livello principale continua a funzionare e il server registra Top-level user_id in /search is deprecated. Use filters={...} instead. ogni volta che lo usi.
Pulisci l'ambiente al termine, in modo che i dati di test non influenzino le ricerche reali:
curl -sS -X DELETE "http://127.0.0.1:8888/memories?user_id=smoke" \
-H "X-API-Key: $MEM0_KEY"Se la ricerca restituisce meno righe del previsto, controlla i valori predefiniti prima di attribuire il problema al recupero. Nella versione attuale, top_k è impostato per impostazione predefinita su 20, invece di 100, mentre threshold è impostato su 0.1 anziché su nessun valore; di conseguenza, le corrispondenze deboli vengono ora filtrate automaticamente. Dopo aver verificato il funzionamento con curl, gli stessi endpoint sono quelli da collegare a un agente, direttamente oppure tramite un server MCP in esecuzione sullo stesso VPS.
Eseguire mem0 senza alcuna chiave OpenAI
Iniziate dal blocco principale, perché lo incontrerete entro i primi cinque minuti. L'immagine del server include un insieme fisso di librerie dei provider e /configure rifiuta qualsiasi valore al di fuori di questo insieme:
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.Non è necessario ricompilare nulla. Ollama espone un'API compatibile con OpenAI su /v1 e supporta /v1/chat/completions e /v1/embeddings. Il provider openai di mem0 accetta un openai_base_url. Indicate Ollama come destinazione della chiave e il controllo incluso ha esito positivo, perché il provider è effettivamente openai. Cambia soltanto l'indirizzo.
Aggiungete Ollama allo stesso progetto Compose:
ollama:
image: ollama/ollama
restart: unless-stopped
networks: [mem0_network]
ports:
- "127.0.0.1:11434:11434"
volumes:
- ollama_models:/root/.ollamaAggiungete ollama_models: alla chiave di livello superiore volumes:, quindi scaricate un modello chat e un modello di embedding:
docker compose up -d ollama
docker compose exec ollama ollama pull llama3.1:8b
docker compose exec ollama ollama pull nomic-embed-textSe Ollama è già in esecuzione sull'host come unità systemd, come descritto in eseguire Ollama direttamente su un VPS, non indirizzate il container a 127.0.0.1:11434. All'interno del container mem0, 127.0.0.1 corrisponde al container mem0. Assegnate al servizio mem0 extra_hosts: ["host.docker.internal:host-gateway"], impostate Environment="OLLAMA_HOST=0.0.0.0:11434" in un drop-in di systemd in modo che Ollama sia in ascolto su un indirizzo raggiungibile dalla rete bridge e mantenete la porta 11434 chiusa nel firewall.
Chiedere al modello la dimensione degli embedding prima di configurare qualsiasi cosa
Questo passaggio determina se il recupero funziona.
Lo store pgvector di mem0 crea la tabella con una larghezza vettoriale fissa, vector vector(1536), perché embedding_model_dims ha come valore predefinito 1536, la larghezza di text-embedding-3-small di OpenAI. nomic-embed-text restituisce 768 valori. Nessun componente interno di mem0 confronta questi due numeri, quindi la mancata corrispondenza viene segnalata da Postgres al primo inserimento:
expected 1536 dimensions, not 768Non fidatevi neppure del numero riportato in questo paragrafo. Chiedetelo al modello:
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']))"Questo comando stampa la larghezza da usare per la collection. Scrivete la configurazione in un file, perché gli errori di battitura in produzione nascono spesso dal passaggio di una password Postgres attraverso l'escaping della 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"La seconda chiamata legge nuovamente la configurazione e verifica che la scrittura sia andata a buon fine. Ripetete quindi lo smoke test precedente.
Quattro dettagli di questo JSON non sono ovvi e ciascuno causa un problema se viene impostato in modo errato.
api_key è la stringa ollama e Ollama ignora il relativo valore. Non può essere vuota, perché la libreria client OpenAI genera un errore prima che qualsiasi richiesta lasci il processo quando non è impostata alcuna chiave. È sufficiente una stringa non vuota.
embedding_model_dims va impostato sul vector store e volutamente non esiste alcun embedding_dims sull'embedder. mem0 invia il parametro OpenAI dimensions soltanto quando impostate embedding_dims; i backend che non implementano il troncamento Matryoshka rifiutano direttamente questo parametro. Impostate la larghezza durante la creazione della tabella e lasciate invariato l'embedder.
collection_name è nuovo. mem0 crea la tabella con CREATE TABLE IF NOT EXISTS, quindi indicare una larghezza diversa per una collection esistente non produce alcun effetto: la vecchia colonna vector(1536) rimane e ogni inserimento fallisce. Per cambiare larghezza serve un nuovo nome di collection oppure è necessario eliminare manualmente la vecchia tabella.
L'host in openai_base_url è il nome del servizio Compose ollama, non localhost. I container si risolvono tra loro tramite il nome del servizio sulla rete condivisa.
Il costo del percorso completamente locale
Siate realistici sulla qualità. I principali punteggi dei benchmark di mem0 provengono dalla sua piattaforma gestita, che secondo il README include ottimizzazioni proprietarie non disponibili nell'SDK open source e viene eseguita su uno stack di modelli che non viene specificato. Il documento di ricerca alla base dei risultati LOCOMO originali eseguiva ogni chiamata al modello su GPT-4o-mini, un modello gestito. In entrambi i casi, considerate questi punteggi un limite superiore, non una previsione per un modello 8B sul vostro VPS. Un modello piccolo produce fatti più vaghi e talvolta restituisce testo discorsivo quando è richiesto JSON. Questo si manifesta con una chiamata add che restituisce un elenco results vuoto senza alcun errore.
La velocità è l'altro costo. L'estrazione eseguita soltanto sulla CPU richiede alcuni secondi per ogni chiamata add e ogni messaggio archiviato comporta questo costo. Un modello che continua oltre il JSON richiesto peggiora il problema. Per questo limitare la risposta con num_predict imposta un limite alla durata di ogni singola chiamata add. Se questa latenza è un problema, un VPS con una GPU collegata è la soluzione corretta. Aggiungere core CPU a un modello 8B aiuta molto meno di quanto ci si aspetti. Cambiare modello è una leva meno costosa rispetto a cambiare macchina e Nemotron 3.5 Lightning su un VPS indica il tag da scaricare, la quantità di RAM necessaria e se le sole CPU offrono prestazioni sufficienti.
Vale sempre una regola: non mischiate mai modelli di embedding nella stessa collection. Due modelli diversi che per caso condividono la stessa larghezza producono vettori non confrontabili. L'inserimento riesce, la ricerca restituisce righe, ma le righe sono errate e non viene segnalato alcun errore.
Backup: ci sono due database, non uno
L’errore più comune nei backup di mem0 consiste nell’eseguire il dump di un solo database. init-db.sh crea mem0_app accanto al database predefinito postgres e i due database contengono dati diversi. Il database postgres contiene le raccolte pgvector, ovvero i ricordi. mem0_app contiene utenti, sessioni, chiavi API e log delle richieste. Ogni applicazione self-hosted suddivide il proprio stato in modo diverso. Per questo due server fotografici che svolgono lo stesso lavoro richiedono comunque comandi di backup diversi. Prima di affidarti a un dump, verifica quali dati archivia l’applicazione. All’estremo opposto si trova un caso come una libreria Jellyfin ricostruita come un videonoleggio degli anni ’90, che legge l’intero catalogo da un altro servizio e quindi richiede poco più della copia della propria configurazione. mem0, invece, richiede entrambi i database; in caso contrario, il ripristino è inutilizzabile.
Se ripristini soltanto postgres, le memorie tornano disponibili ma tutti gli account e le chiavi API scompaiono. Di conseguenza, nessun componente può autenticarsi per leggerle. Esegui il dump di entrambi i database, insieme ai ruoli, con un solo comando:
docker compose exec -T postgres pg_dumpall -U postgres --clean \
| gzip > "mem0-$(date +%F).sql.gz"Il volume della cronologia è separato da Postgres e richiede una propria copia:
docker run --rm -v mem0_mem0_history:/data -v "$PWD:/backup" \
alpine tar czf /backup/mem0-history.tgz -C /data .Docker antepone ai nomi dei volumi il nome del progetto. Verifica il nome con docker volume ls prima di dare per scontato che sia mem0_mem0_history.
Ripristina il backup in un container temporaneo e controlla il numero di righe prima di considerarlo valido:
gunzip -c mem0-2026-08-03.sql.gz \
| docker compose exec -T postgres psql -U postgres -d postgresUn backup che non hai mai ripristinato è soltanto un’ipotesi. Quando i dump sono corretti, trasferiscili fuori dal server con snapshot restic su storage esterno, perché un backup che risiede sul server che dovrebbe proteggere non protegge nulla.
Modalità di errore e stringhe esatte visualizzate
{"detail":"Authentication required. Provide a Bearer token or X-API-Key header."} indica che l'header manca o contiene un errore di ortografia. Il nome è X-API-Key e curl invia i nomi degli header alla lettera.
{"detail":"At least one identifier (user_id, agent_id, run_id) is required."} durante un'operazione di aggiunta indica che la richiesta non ne conteneva nessuno. Una memoria deve essere associata a un ambito, perché la ricerca applica i filtri esattamente a quei campi.
LLM provider 'ollama' is not bundled in this image con HTTP 400 indica che hai inviato "provider": "ollama". Usa "provider": "openai" con openai_base_url configurato per puntare a Ollama.
expected 1536 dimensions, not 768 da Postgres indica che la raccolta è stata creata con una dimensione e l'embedder ne restituisce un'altra. Imposta embedding_model_dims nell'archivio vettoriale e usa un nuovo collection_name.
La ricerca restituisce righe prive di senso dopo una modifica del modello, senza errori visibili. La dimensione dei vettori è ancora compatibile, quindi il database non segnala problemi, ma due modelli collocano la stessa frase in posizioni diverse. Crea una nuova raccolta e aggiungi nuovamente i dati.
Connection refused nei log di mem0 durante il collegamento a Ollama indica in genere 127.0.0.1 in openai_base_url. All'interno del container, quell'indirizzo identifica il container stesso. Usa il nome del servizio oppure il gateway dell'host quando Ollama viene eseguito sull'host.
504 Gateway Time-out da nginx durante un'operazione di aggiunta indica che il modello ha impiegato più di proxy_read_timeout. Aumenta questo valore e verifica se la memoria è stata comunque scritta prima di ripetere la richiesta.
exit code 137 durante docker compose up --build indica che un processo è stato terminato con SIGKILL, perché un segnale fatale N viene riportato come 128 + N e SIGKILL corrisponde al segnale 9. Durante la compilazione della dashboard su un VPS con risorse limitate, il responsabile più probabile è il killer per mancanza di memoria. Esegui quindi il controllo dmesg della prima sezione prima di intervenire. Se il controllo mostra un processo terminato, aggiungi swap oppure crea l'immagine su una macchina più potente e inviala a un registry.
error: port 3000 is already in use proviene dal target make up del repository, che non si avvia quando le porte 3000 o 8888 sono già occupate. Individua il processo proprietario con lsof -iTCP:3000 -sTCP:LISTEN.
FAQ
Devo ancora usare Neo4j per eseguire mem0 con la memoria a grafo?
No. Il nuovo algoritmo di memoria, rilasciato ad aprile 2026, ha rimosso le chiavi di configurazione graph_store e enable_graph dall'SDK open source. L'estrazione delle entità viene ora eseguita durante una normale operazione di add e scrive in una seconda raccolta pgvector denominata <collection_name>_entities, quindi non sono necessari un database a grafo esterno, un container aggiuntivo o una fase di configurazione. Il compromesso è che il campo relations non è più presente nei risultati della ricerca. Le entità ora aumentano il ranking di una memoria invece di fornire archi da attraversare, quindi un'applicazione che percorreva queste relazioni deve usare un proprio archivio a grafo esterno a mem0.
Qual è il VPS più piccolo su cui eseguire un server mem0 self-hosted?
Se il modello linguistico è ospitato altrove, 2 GB di RAM e circa 4 GB di spazio libero su disco sono sufficienti per il container API, Postgres e la dashboard. Il momento più impegnativo è la prima build, perché la compilazione della dashboard Next.js usa più memoria dell'esecuzione normale e su una macchina con 1 GB la build viene terminata con exit code 137. Se Ollama viene eseguito sullo stesso server, dimensiona il VPS in base al modello: un modello 8B con quantizzazione a 4 bit richiede da solo circa 6 GB, quindi prevedi 8 GB.
Posso eseguire mem0 senza una chiave API OpenAI?
Sì, tramite l'endpoint compatibile con OpenAI di Ollama. L'impostazione di "provider": "ollama" non funziona, perché l'immagine del server include solo le librerie openai, anthropic e gemini e restituisce HTTP 400. Mantieni invece "provider": "openai" e imposta "openai_base_url": "http://ollama:11434/v1" con un valore api_key non vuoto, sia per llm sia per l'embedder. Ollama ignora la chiave e il controllo del provider incluso va a buon fine perché il provider è effettivamente openai.
Perché mem0 non restituisce risultati dopo il passaggio a un modello di embedding locale?
Perché la tabella pgvector è stata creata con una dimensionalità fissa. embedding_model_dims ha come valore predefinito 1536, nomic-embed-text restituisce 768 e Postgres rifiuta l'inserimento con expected 1536 dimensions, not 768. mem0 crea la tabella usando CREATE TABLE IF NOT EXISTS, quindi modificare soltanto il numero non produce effetti su una raccolta esistente. Imposta embedding_model_dims sulla dimensionalità effettiva del modello, verifica tale dimensionalità chiamando /v1/embeddings e contando i valori restituiti, quindi assegna contemporaneamente all'archivio vettoriale un nuovo collection_name.