Mnemo con Ollama: memoria locale, deployment e controllo

Il tuo modello Ollama sa già rispondere alle domande, ma ogni conversazione riparte da zero. La decisione di progetto discussa ieri, la preferenza impostata oggi e il vincolo che ti servirà domani spariscono.

Questo è il problema di memoria negli LLM locali. Ollama offre un servizio modello capace di rispondere. Che cosa risponde, e se ricorda i vincoli che gli hai già dato, dipende da quanto contesto ripeti a mano in ogni prompt.

Mnemo non sta rifacendo un RAG. Usa un grafo di conoscenza e l’estrazione di entità per gestire memoria a lungo termine, così il tuo LLM locale può ricordare decisioni di progetto e relazioni tra entità invece di chiederti ogni volta: “a cosa serve questa API?“

1. Che cos’è Mnemo: posizionamento e capacità principali

1.1 Leggere il posizionamento

In “local-first AI memory layer” contano due parti:

• local-first: i dati restano sulla tua macchina, non vanno nel cloud, sono migrabili e non dipendono dalla vita di un SaaS
• memory layer: non è un altro RAG e non è un altro framework per agent. Si occupa della memoria stessa: estrazione di entità, costruzione del grafo e retrieval semantico

Per esempio, chiedi “qual è l’URL base dell’API di questo progetto?”. Una ricerca vettoriale pura può restituire vari frammenti collegati ad “API”, ma non sa a quale progetto ti riferisci. Il retrieval su grafo può seguire la catena “progetto -> API -> baseUrl” e restituire il valore di configurazione impostato prima.

Il presupposto è che l’estrazione di entità sia corretta. Se il LLM divide “URL base dell’API” in due entità, “API” e “URL base”, il grafo si frammenta e il retrieval perde il collegamento. L’accumulo di rumore parte da qui.

Chiarito il posizionamento, le capacità principali si leggono meglio.

1.2 Matrice delle capacità principali

Il README di Mnemo elenca quattro capacità:

1. persistent knowledge graph (grafo di conoscenza persistente)

   • Entità e relazioni vengono salvate in SQLite, non in vettori usa e getta
   • La struttura del grafo può essere interrogata, esportata e migrata

2. entity extraction (estrazione di entità)

   • Identifica automaticamente entità nelle conversazioni, come persone, nomi di progetto, nomi API e decisioni
   • Non è puro retrieval vettoriale. Trasforma “a cosa serve questa API?” in una struttura entità-relazione interrogabile
   • La qualità dipende dalla comprensione del LLM. LLM locali come llama3 possono riconoscere male le entità in conversazioni complesse, e il rumore si accumula. Il README non offre una pulizia automatica, quindi devi controllare periodicamente la qualità del grafo

3. semantic retrieval (retrieval semantico)

   • Combina ricerca full-text nei chunk, ricerca per nome delle entità, espansione del grafo, filtro delle relazioni e ranking pesato
   • Riduce il peso dei risultati espansi, così le corrispondenze dirette superano le relazioni inferite e il contesto resta limitato

4. graph-first vs pure vector search

La ricerca vettoriale pura chiede: “che cosa è simile?”. Il retrieval su grafo chiede: “che cosa è collegato?”. La prima può restituire rumore simile ma irrilevante. Il secondo segue catene di relazione tra entità.

Il confronto rende il punto più chiaro:

1.3 Stack tecnico e licenza

Stack tecnico:

Vultr - Cloud server NVMe ad alte prestazioni, 32 location globali, deploy Docker con un clic

Vedi prezzi →Pubbl.

• Rust, diviso in quattro crate descritte nella sezione successiva
• SQLite per archiviazione locale in modalità WAL
• petgraph per il grafo in memoria
• API OpenAI, Ollama o Anthropic come backend LLM

Licenza: MIT License. Puoi usarlo, modificarlo e ridistribuirlo.

Promemoria sui rischi:

• Progetto in fase iniziale, basato sul README GitHub del 2026-06-05
• API e architettura possono cambiare
• Non c’è una validazione di produzione su larga scala documentata
• I numeri di performance del README sono misure interne, non una prova indipendente

2. Architettura: quattro crate Rust

Mnemo è scritto in Rust e diviso in quattro crate con responsabilità chiare:

mnemo-core: logica principale

• Estrazione di entità, costruzione del grafo e logica di retrieval
• Non dipende da un backend LLM specifico; definisce le interfacce

mnemo-api: server

• Espone l’API HTTP, sulla porta predefinita 8080
• Riceve conversazioni, chiama core e restituisce risultati
• Health check: curl http://localhost:8080/health

mnemo-cli: strumento da riga di comando

• Debug, gestione e query
• Chiama l’API Mnemo via HTTP per ingestion, retrieval, controllo delle entità e cancellazione completa

mnemo-bench: benchmark di performance

• I 122 Rust tests, 21 Python tests e 12 benchmarks del README sono collegati a questa parte
• Fonte delle misure dichiarate dal progetto

Vantaggi della divisione in quattro crate:

• core si può testare da solo, senza dipendere dall’API
• cli semplifica il debug locale senza avviare il servizio
• bench resta separato e non incide sul codice di produzione

Svantaggi:

• Senza Docker serve la toolchain Rust completa
• Quando cambiano le API tra crate, spesso vanno aggiornati più punti insieme

3. Installazione e deployment: tre percorsi

Mnemo offre tre percorsi di deployment, ordinati per complessità:

3.1 Docker + Ollama: il modo più rapido per iniziare

Prerequisiti: Docker e Ollama installati.

# 1. clona il progetto
git clone https://github.com/zaydmulani09/mnemo.git
cd mnemo

# 2. avvia Docker
docker compose up -d

# 3. scarica il modello dentro Docker
docker exec mnemo-ollama ollama pull llama3

# 4. health check
curl http://localhost:8080/health

Nota: i comandi possono cambiare. Usa il README GitHub come fonte di verità.

Spiegazione: Docker compose avvia due container: mnemo-api, il server, e mnemo-ollama, il servizio Ollama. Il secondo è opzionale. Se Ollama è già in esecuzione in locale, puoi usare solo il container mnemo-api e collegarlo al tuo Ollama locale con MNEMO_LLM_BASE_URL=http://host.docker.internal:11434/v1.

Verificare la connessione LLM: quando l’health check restituisce {"status":"ok"}, l’API è avviata, ma la connessione LLM non è ancora verificata. Invia una richiesta di test con curl:

curl -X POST http://localhost:8080/ingest \
  -H "Content-Type: application/json" \
  -d '{"content":"Il progetto Atlas usa https://api.example.test come URL base","source":"chat","session_id":"mnemo-trial"}'

Dopo la scrittura, chiama /retrieve per verificare il retrieval:

curl -X POST http://localhost:8080/retrieve \
  -H "Content-Type: application/json" \
  -d '{"text":"Qual è l URL base dell API Atlas?","session_id":"mnemo-trial"}'

Se la risposta contiene entità, chunk di memoria o context_prompt, estrazione e retrieval funzionano.

🔥 Non sprecare mesi su prodotti senza domanda! Valida i punti di forza del tuo SaaS con Adsterra e un piccolo budget →

Testa ora →Pubbl.

Vantaggi:

• Non serve la toolchain Rust
• Docker gestisce le dipendenze automaticamente
• Ollama e Mnemo sono nella stessa rete compose, quindi la rete è semplice

Svantaggi:

• Docker consuma risorse
• Il debug è meno comodo, perché per vedere SQLite devi entrare nel container
• I log sono distribuiti tra due container

3.2 Binary: compilazione locale

Prerequisiti: toolchain Rust installata, inclusi cargo e rustc, e Ollama installato.

# 1. clona il progetto
git clone https://github.com/zaydmulani09/mnemo.git
cd mnemo

# 2. compila la crate API
cargo install --path crates/mnemo-api

# 3. configura l'indirizzo Ollama
export MNEMO_LLM_BASE_URL=http://localhost:11434/v1

# 4. avvia il servizio
mnemo-api

Nota: i comandi possono cambiare. Usa il README GitHub come fonte di verità; questo percorso richiede una toolchain Rust.

Spiegazione: il tempo di compilazione dipende dall’hardware e dalla cache Cargo. Dopo il build, mnemo-api usa per impostazione predefinita mnemo.db nella directory corrente. Puoi cambiare il percorso con MNEMO_DB_PATH o la configurazione TOML.

Verificare la connessione Ollama: prima dell’avvio, conferma che Ollama sia in ascolto su localhost:11434 e che il modello sia stato scaricato con ollama pull llama3. Dopo l’avvio, prova con curl:

curl -X POST http://localhost:8080/ingest \
  -H "Content-Type: application/json" \
  -d '{"content":"Testare l estrazione di entità Mnemo","source":"cli-check"}'

Vantaggi:

• Non dipende da Docker
• Più facile da debuggare, perché è un processo locale e i log restano nello stesso terminale
• Puoi usare mnemo-cli direttamente su SQLite locale
• Porta e percorso del database si possono personalizzare con variabili d’ambiente

Svantaggi:

• Serve la toolchain Rust completa
• La prima compilazione può richiedere tempo
• Le dipendenze possono creare problemi, per esempio se cargo.lock è obsoleto

3.3 OpenAI-compatible: LLM cloud

Prerequisiti: hai una API key OpenAI, Anthropic o di un altro backend OpenAI-compatible.

Elenco delle variabili d’ambiente, verificato sul README GitHub di 2026-06:

export MNEMO_LLM_BASE_URL=https://api.openai.com/v1
export MNEMO_LLM_API_KEY=sk-...
export MNEMO_LLM_MODEL=gpt-4o-mini
export MNEMO_LLM_PROVIDER=openai

Poi avvia:

mnemo-api

Nota: i nomi delle variabili possono cambiare. Usa il README GitHub come fonte di verità.

Casi adatti:

• La macchina locale non ha abbastanza calcolo e usi un LLM cloud
• Hai già quota API OpenAI
• Accetti che il contenuto delle conversazioni venga inviato all’API cloud. Con un LLM cloud, il vantaggio local-first vale solo per l’archiviazione locale, non per il traffico di inferenza

Scegli uno dei tre percorsi in base alla tua situazione. Poi si guarda alla performance.

4. Performance: misure dichiarate nel README

Il README di Mnemo elenca misure proprie, verificate di nuovo il 17 luglio 2026:

Condizioni di test:

KiloClaw - OpenClaw gestito per enterprise: orchestrazione agenti IA e routing intelligente

Inizia →Pubbl.

• Apple M2, debug build
• SQLite in modalità WAL
• petgraph in memoria

Numeri di performance:

• Pipeline completa di retrieval: circa 4,2 ms
• Release build dichiarata 3-5x più veloce, circa 0,8-1,4 ms

Nota: è una misura del README, non una prova indipendente. Le performance cambiano con hardware, volume dei dati e backend LLM.

Come leggere questi numeri:

• 4,2 ms è tempo di retrieval, non tempo di inferenza LLM. Il collo di bottiglia è l’inferenza LLM
• SQLite WAL più grafo in memoria può rendere il retrieval davvero rapido
• Questa è solo la fase di retrieval, non la velocità della conversazione

L’esperienza reale dipende da:

• tempo di inferenza LLM, molto più lento del retrieval
• lunghezza della conversazione, perché anche l’estrazione di entità richiede inferenza LLM
• volume dei dati, perché un grafo più grande può rallentare la ricerca

Suggerimento: esegui mnemo-bench sull’hardware di destinazione. I numeri del README sono un riferimento, non una promessa.

5. Caratteristiche local-first e confini

5.1 Vantaggi local-first

Il cuore del local-first è semplice: i dati restano sulla tua macchina.

Vantaggi concreti:

1. Protezione della privacy

   • Conversazioni, entità e relazioni vengono salvate in SQLite locale
   • Non vengono caricate su un SaaS di terze parti, a patto di usare un LLM locale

2. Controllo dei dati

   • Il file SQLite può essere esportato, salvato in backup e migrato
   • Non dipendi dalla vita di un SaaS. I dati restano con te

3. Portabilità

   • Quando cambi macchina, copi il file SQLite
   • Non devi “addestrare” di nuovo la memoria

4. Debuggabilità

   • SQLite è un formato standard e si può ispezionare con qualunque strumento SQLite
   • La struttura del grafo è visibile, non un vettore black box

5.2 Rischi e confini

Local-first ha vantaggi, ma anche rischi:

1. Accumulo di rumore

   • L’estrazione di entità non è perfetta e può sbagliare
   • Entità identificate male influenzano i retrieval successivi
   • Serve pulizia periodica, ma Mnemo non offre una pulizia automatica
   • L’accumulo di rumore non è un problema solo di Mnemo; riguarda tutti i sistemi di memoria automatica. La differenza è che il grafo di Mnemo è visibile. Puoi vedere entità rumorose e relazioni sbagliate. Nei sistemi vettoriali il rumore resta nascosto nei vettori. È un vantaggio del grafo, ma anche lavoro di manutenzione

2. Limiti di eliminazione e ripristino

   • L’API attuale elimina una singola entità, un chunk di memoria o tutto il contenuto con un header di conferma
   • Non offre una transazione di alto livello per annullare l’ultima scrittura o una decisione completa
   • Se un errore si è esteso a più entità e relazioni, usa i dati source o session per delimitare cosa eliminare prima di ripristinare un backup
   • Aggiungi source, session_id e un ID di audit alle decisioni importanti e verifica l’estrazione prima di salvare fatti reali

3. Hidden state

   • La struttura del grafo può contenere relazioni che non noti
   • Il retrieval può restituire risultati senza rendere chiaro il motivo

4. Confini di utilizzo

   • Con grandi volumi, SQLite + grafo in memoria può andare sotto pressione
   • La condivisione tra agent richiede autorizzazione, isolamento e gestione operativa che Mnemo non fornisce da solo

5.3 Tabella decisionale: adatto vs non adatto

Giudizio: se lo scenario è “progetto personale, alta privacy, Ollama già presente e volume dati moderato”, Mnemo merita una prova. Se invece è “grande volume, collaborazione di team, memoria globale condivisa”, conviene aspettare più maturità o valutare un’altra soluzione.

Suggerimenti concreti:

• Esegui prima il percorso Docker in un ambiente di test e controlla struttura del grafo, qualità dell’estrazione entità e risultati di retrieval
• Usa conversazioni di test per misurare il rischio di rumore. Di’ intenzionalmente cose irrilevanti e guarda se Mnemo le identifica male
• Prepara un piano di pulizia. Impara presto la struttura SQLite, così saprai eliminare a mano entità sbagliate
• Segui gli aggiornamenti del README. Il progetto è giovane: API, architettura e comandi di deployment possono cambiare

6. Prossimo passo: navigazione della serie

Se non hai ancora letto gli articoli precedenti della serie Ollama local LLM, segui questo ordine:

1. Guida introduttiva a Ollama: il primo passo per eseguire un grande modello linguistico in locale

   • Parti da qui se non hai ancora installato Ollama

2. Chiamate API Ollama: da curl all’interfaccia compatibile con OpenAI SDK

   • Mnemo usa un’API OpenAI-compatible, quindi conviene capire l’interfaccia API di Ollama

3. Ollama Embedding in pratica: ricerca vettoriale locale e RAG

   • Serve a confrontare la ricerca vettoriale pura con la pipeline full-text, entità e grafo di Mnemo

4. Gestione della memoria per AI Agent: memoria a lungo termine e governance della conoscenza

   • Mnemo è uno strumento per il layer di memoria; questo articolo copre la governance della memoria degli agent

Dopo questi quattro articoli, installa Mnemo ed esegui il percorso Docker in locale. Il primo risultato utile è vedere che forma ha davvero il grafo di conoscenza.