Da allora ho lavorato molto sul progetto, aggiungendo funzionalità, migliorando la stabilità e rendendo tutto più facile da usare.

Da Ollama a Ollama e LM Studio

Una delle richiesta più comuni che ho visto in giro per progetti simili è la possibilità di usare backend diversi. Nel primo post parlavo solo di Ollama come backend AI. Ora lo strumento supporta anche LM Studio, con API OpenAI-compatibili.

Che significa, in pratica? Se desideri avere più controllo e scelta di modelli, puoi usare LM Studio senza cambiare nulla nel flusso di lavoro. Nell’interfaccia web e nella CLI il passaggio è trasparente: basta cambiare il backend nei parametri e puntare all’URL del server corretto.

Deduplicazione tempo e spazio, non solo semantica

Nel post originale parlavo di clustering semantico: le foto venivano raggruppate per similarità di descrizione e poi selezionate a rotazione per evitare ripetizioni. Funzionava, ma a volte finivo comunque con foto troppo simili, scattate nello stesso istante e nella stessa posizione.

Ho aggiunto un secondo livello di deduplicazione temporale e geografica. Dopo la selezione iniziale, lo strumento rimuove automaticamente le foto che sono entro 30 secondi e 100 metri l’una dall’altra, tenendo sempre quella con il ranking estetico migliore.

Il risultato è un album più vario, con meno “serie di foto quasi identiche” e più momenti distinti.

Logging professionale con Logback

Il primo prototipo scriveva log in modo un po’ artigianale, spesso su stdout o in file senza gestione. Per un tool che può girare automaticamente su grandi archivi, serve qualcosa di più robusto.

Ora il progetto usa Logback con:

• logging su file (logs/photoprism-ai.log)
• rotazione giornaliera
• retention di 7 giorni
• nessun output su stdout, tranne barre di progresso essenziali

Nel log trovi:

• prompt di clustering (DEBUG)
• rimozioni per dedup temporale/spaziale (INFO)
• nomi dei cluster finali (INFO)

Prompt emozionale e descrizioni più ricche

Uno dei problemi iniziali era che il modello multimodale produceva descrizioni troppo brevi o generiche, il che rendeva il clustering meno efficace.

Ho:

• aumentato la descrizione a 30 parole per ogni foto
• introdotto un prompt emozionale più ricco, per spingere il modello a valutare anche composizione, originalità e “atmosfera”, non solo要素 tecnici

Il clustering ne beneficia molto: le categorie sono più pulite e coerenti.

Batch, thread e performance

Nel primo post parlavo di timeout e latenza come principali colli di bottiglia. Ho fatto diversi affini:

• batch da 30 richieste per il clustering
• 3 thread per il processing parallelo
• caching più intelligente di takenAt, titolo, coordinate e luogo
• retry automatico 3× per le chiamate AI in caso di errore

Questi cambiamenti hanno reso il tool più stabile e veloce, soprattutto su archivi grandi.

Barra di progresso e Web UI

La CLI funziona bene, ma per molti utenti un’interfaccia visuale è più comoda. Ho quindi sviluppato una Web UI leggera con:

• Javalin come server embedded
• HTMX per dinamicità senza scrivere JavaScript complesso
• una barra di progresso per il clustering, con conteggio batch in tempo reale

La Web UI permette di:

• scegliere mese singolo o anno intero
• specificare quante foto selezionare
• personalizzare il prompt di valutazione
• scegliere il nome dell’album

Il form è semplice, ma copre tutti i casi d’uso principali.

Modalità anno intero

Nel post originale parlavo solo di selezione per mese. Ora c’è anche una modalità anno intero: lo strumento processa tutti i 12 mesi in sequenza, accumulando le foto migliori di ogni mese in un unico album annuale.

È utile per creare album tipo “Best of 2025” o “Viaggi 2025” senza dover lanciare manualmente 12 selezioni separate.

Cache arricchita e pool temporaneo

La cache (ai-cache.json) ora conserva per ogni foto:

• score estetico
• descrizione generata dall’AI
• cluster assegnato
• titolo, coordinate, takenAt, placeLabel, placeCity, placeState, placeCountry

Il pool temporaneo pre-dedup viene salvato in {albumName}.json, utile per debug e analisi.

CLI più flessibile

Oltre alla Web UI, la CLI è più potente:

bash# Mese singolo
java -jar target/photoprism-ai-curator-1.0.1.jar \
  --no-web --mode month --month 1 --year 2026 \
  --count 20 --album "Mia Selezione"

# Anno intero
java -jar target/photoprism-ai-curator-1.0.1.jar \
  --no-web --mode year --year 2026 \
  --count 20 --album "Best of 2026"

# Prompt personalizzato
java -jar target/photoprism-ai-curator-1.0.1.jar \
  --no-web --mode month --month 1 --year 2026 \
  --count 20 \
  --prompt "Rate composition and originality"

Sono disponibili flag per:

• percorso del config file
• forzatura modalità CLI
• modalità mese/anno
• mese, anno, conteggio foto
• nome album
• prompt di valutazione

Struttura del progetto

Il progetto è ora più maturo e meglio organizzato:

• AiBackend come interfaccia comune per rating e clustering
• OllamaClient e LmStudioClient come implementazioni separate
• PhotoFetcher, AISelector, AlbumManager, ImageHasher come servizi puliti
• WebServer con Javalin + HTMX
• JobContext per lo stato thread-safe dei job

Tutto il codice è in Java 17+, con Maven, JUnit 5 e Mockito per i test.

Perché questi aggiornamenti contano

Per me, il punto non è solo automatizzare una classifica di bellezza. Il vero valore sta nel:

• combinare giudizio estetico, varietà narrativa e vincoli pratici
• gestire cache, timeout e costi computazionali in modo intelligente
• offrire un’alternativa locale e controllabile ai servizi cloud per la selezione foto

Con LM Studio, dedup tempo/spazio, Logback, Web UI e modalità anno intero, ritengo che il progetto sia oggi molto più pronto per l’uso quotidiano.

Tutti i dettagli tecnici, commit e modifiche sono disponibili su GitHub.
La commit history è qui: https://github.com/b0sh-net/photoprism-ai-curator/commits/master/.

Da qui è nata l’idea di un selezionatore AI: una piccola applicazione Java che usa PhotoPrism per recuperare le miniature delle immagini e Ollama per far lavorare due modelli AI, uno multimodale per assegnare un punteggio estetico e produrre una descrizione oggettiva, e un secondo modello testuale per raggruppare semanticamente le foto e selezionarle con più equilibrio.

Il problema vero non era la qualità

Il primo prototipo faceva una cosa molto semplice: prendere le foto da PhotoPrism, inviarle a un modello multimodale su Ollama e chiedere un voto estetico da 1 a 100 insieme a una breve descrizione. Sulla carta sembrava sufficiente, ma in pratica produceva una selezione monotona: immagini molto belle singolarmente, ma spesso troppo simili tra loro.

Era il classico caso in cui un ranking puro ottimizza la qualità locale ma non la copertura narrativa. Se cinque foto dello stesso scorcio o dello stesso momento ricevono voti alti, un algoritmo ingenuo tende a sceglierle tutte. Per costruire un album da condividere, invece, non basta premiare le immagini migliori: bisogna anche evitare la ripetizione.

Dalla classifica ai cluster

La seconda iterazione ha quindi cambiato approccio. Invece di trattare il problema come una semplice classifica, il tool ha iniziato a ragionare per gruppi: ogni foto riceve una descrizione oggettiva dal modello visivo, e queste descrizioni vengono poi analizzate da un secondo modello text-only per creare cluster di immagini semanticamente simili.

In questo modo la selezione finale non è più dominata da un unico soggetto o da una sola scena. Il sistema sceglie a rotazione le migliori foto da cluster diversi, così da conservare un livello qualitativo alto senza sacrificare la varietà. È un cambiamento piccolo da spiegare, ma sostanziale nel risultato: da “le più belle” a “le più belle che, insieme, raccontano meglio il viaggio”.

Il collo di bottiglia era la latenza

La parte più difficile non è stata immaginare la pipeline, ma farla funzionare in tempi accettabili. Creare i cluster su un numero elevato di immagini si è rivelato più costoso del previsto, soprattutto per il tempo necessario a far processare le descrizioni dal modello. Per questo la pipeline è stata spezzata in blocchi parziali, poi riunificati in una fase finale di merge, così da ridurre il costo operativo del clustering su un set grande.

Anche così, però, i timeout continuavano a essere un problema reale. La svolta è arrivata intervenendo direttamente sulle chiamate verso Ollama: per il modello dedicato al clustering è stata disabilitata la fase di thinking, usando richieste batch con think:false, così da evitare lunghi passaggi riflessivi non necessari per questo tipo di compito. È stata la scelta risolutiva, soprattutto con i modelli Qwen, che tendono ad avere una fase riflessiva di default piuttosto lunga.

Cosa fa la prima beta

La prima beta, pubblicata come PhotoPrism AI Curator, automatizza l’intero flusso: scarica le miniature delle foto da PhotoPrism, invia ciascuna miniatura a Ollama con un modello multimodale per ottenere un punteggio estetico e una descrizione, raggruppa le immagini per similarità semantica tramite un secondo modello text-only, seleziona a rotazione le migliori da ciascun gruppo e crea infine un album direttamente in PhotoPrism. Questa architettura è coerente con le capacità offerte da PhotoPrism per organizzazione, persone e label, e con il ruolo di Ollama come runtime locale per modelli diversi nello stesso workflow.

Il progetto include anche una modalità “anno intero”, che processa tutti i dodici mesi in sequenza e accumula le migliori foto mensili in un unico album annuale. È una funzione semplice da descrivere ma molto pratica per chi usa PhotoPrism come archivio personale continuo e non vuole lavorare manualmente mese per mese.

Stack e funzionamento

Dal punto di vista tecnico, il progetto richiede Java 17+, Maven, un’istanza PhotoPrism con API attiva e Ollama con almeno due modelli: uno multimodale per l’analisi visiva, come minicpm-v, llava o moondream, e uno text-only per il clustering delle descrizioni, come qwen3.5:4b o llama3.2:3b. In alternativa è possibile usare un solo modello capace di gestire sia input visivi sia generazione testuale pura, ma l’architettura pensata per la beta separa chiaramente valutazione estetica e clustering semantico.

L’applicazione si compila con Maven, legge la configurazione da config.properties e consente di impostare URL e token di PhotoPrism, endpoint Ollama, modelli da usare, prompt di valutazione, file di cache e timeout per connessione, rating e clustering. Il fatto di mantenere una cache locale delle valutazioni in ai-cache.json è importante, perché evita di ripetere inferenze costose su immagini già processate e rende molto più sopportabile l’uso iterativo durante i test.

Web UI invece di solo CLI

Un aspetto interessante della beta è che non si ferma alla linea di comando. Il progetto espone anche una piccola interfaccia web embedded, avviabile direttamente dal JAR, costruita con Javalin lato server e HTMX nel frontend, una scelta leggera ma molto sensata per questo tipo di utility locale. L’interfaccia permette di scegliere se elaborare un mese singolo o l’intero anno, indicare quante foto selezionare, personalizzare il prompt di valutazione e decidere il nome dell’album finale.

Questa parte è importante anche narrativamente, perché mostra che il progetto non è solo una prova tecnica. C’è già il tentativo di trasformare uno script nato per uso personale in uno strumento riutilizzabile, con uno stato di job thread-safe e una UX minima ma concreta.

Struttura del progetto

La struttura del repository rende abbastanza chiara l’evoluzione del tool. I client separano le API di PhotoPrism e Ollama, i service isolano fetch delle foto, logica di selezione, hashing e gestione degli album, mentre il pacchetto web contiene il server e il contesto di esecuzione dei job. È una divisione ordinata che aiuta a leggere il progetto come una pipeline composta da fasi distinte: raccolta, valutazione, raggruppamento, selezione, pubblicazione.

In breve, l’albero principale comprende App.java come entry point, una configurazione dedicata, model per foto e album, client per PhotoPrism e Ollama, service per selezione e gestione operativa, e una web UI HTMX servita da Javalin. Anche la scelta di usare JUnit 5 e Mockito per i test indica che la beta non è soltanto un esperimento estemporaneo, ma un progetto già pensato per crescere.

Perché mi interessava davvero

La cosa più interessante di questo progetto non è tanto aver fatto scegliere delle foto a un’AI. Il punto è aver trasformato un problema quotidiano e noioso — rientrare da un viaggio e dover setacciare centinaia di immagini quasi uguali — in una pipeline locale, controllabile e compatibile con strumenti self-hosted già esistenti.

PhotoPrism sa già dove sono state scattate le foto, chi compare nelle immagini e quali label possono descriverle, ma il salto verso una vera selezione richiede qualcosa in più: un giudizio estetico, una nozione minima di varietà e una serie di compromessi pratici su latenza, timeout e costo computazionale. È proprio in quel punto, tra metadata e gusto, che questo selezionatore AI prova a inserirsi.

Come provarlo

Per compilare la beta basta clonare il repository, copiare config.properties.example in config.properties, inserire i dati della propria istanza PhotoPrism e di Ollama e lanciare mvn clean package. A quel punto si può avviare il JAR in modalità web oppure usare la CLI con il file di configurazione passato esplicitamente.

bashgit clone <url-repo>
cd photoprism-ai-curator
cp config.properties.example config.properties
# modifica config.properties con i tuoi dati
mvn clean package
java -jar target/photoprism-ai-curator-1.0.0.jar

Una volta aperta l’interfaccia web su http://localhost:8080, il flusso è lineare: scegliere il periodo, indicare il numero di foto desiderate, adattare eventualmente il prompt di valutazione e lasciare che il sistema costruisca l’album finale dentro PhotoPrism.

Cosa può diventare

Questa prima beta risolve già il problema più concreto: ridurre una massa di foto a una selezione più pulita, più varia e più condivisibile. Ma lascia intravedere sviluppi interessanti, come criteri di selezione personalizzabili per tipo di viaggio, un bilanciamento più esplicito tra soggetti, luoghi e momenti, oppure un uso più intelligente dei metadata di PhotoPrism per influenzare il clustering e la rotazione finale.

Il progetto è già disponibile in una prima beta su GitHub, qui: b0sh-net/photoprism-ai-curator. Dentro al repository ci sono codice, istruzioni di compilazione, configurazione di PhotoPrism e Ollama, oltre alla piccola interfaccia web che ho costruito per rendere il flusso più comodo da usare.

La prova più interessante non è stata nemmeno il primo avvio fallito su Fedora in VM, ma il confronto tra ambienti diversi. Su una macchina fisica Windows con GPU, OpenHuman parte; appena si entra nel flusso di configurazione, però, emergono subito domande poco rassicuranti: login cloud richiesto, collegamento Gmail mediato da un servizio terzo, e una catena di dipendenze che rende il concetto di “locale” molto più sfumato di quanto il marketing lasci intendere.

Un progetto che promette molto

OpenHuman si presenta come un assistente personale AI locale, capace di integrarsi con servizi esterni, gestire memoria e collegarsi a modelli LLM sia in locale sia in cloud. Il pitch è forte: un agente “human-centric”, pronto a conoscersi in pochi minuti e a diventare parte del flusso di lavoro quotidiano.

Ed è proprio qui che nasce il problema. Più la promessa è ambiziosa, più ci si aspetta che il setup sia semplice, trasparente e affidabile. Invece la mia esperienza è stata l’opposto: ogni passo sembrava introdurre un nuovo livello di complessità, spesso non spiegato bene all’utente.

Fedora in VM: crash, errori e packaging fragile

Il primo test è stato su Fedora in macchina virtuale. Qui OpenHuman ha mostrato subito il suo lato più fragile. L’installazione è partita velocemente, ma all’avvio il programma non è riuscito a completare il bootstrap in modo stabile. I log hanno iniziato a restituire errori diversi a ogni tentativo, e questo è già di per sé un pessimo segnale.

Tra i messaggi più significativi c’erano:

textVMware: No 3D enabled

e soprattutto:

textError initializing NSS with a persistent database
version `NSSUTIL_3.108' not found
FATAL: nss_error=-5925

In pratica, il pacchetto distribuiva librerie incompatibili con quelle presenti sul sistema. Il risultato non era solo un crash, ma un crash dovuto a un conflitto abbastanza banale da sembrare quasi un errore di packaging elementare. Ho provato anche a forzare l’esecuzione con estrazione manuale dell’AppImage, variabili ambientali diverse e disabilitazione della GPU, ma senza successo.

A quel punto il problema non era più il singolo workaround: era il fatto che il software, su una configurazione abbastanza comune come Fedora in VM, falliva in modo ripetuto e poco affidabile.

Windows con GPU: parte, ma non convince

Su una macchina fisica Windows con GPU, OpenHuman si installa e si avvia. Questo però non ha risolto il mio giudizio, anzi lo ha reso più netto. La prima sorpresa è stata la richiesta di un login cloud già al primo avvio, cosa che stride parecchio con l’immagine di applicazione locale e privacy-oriented.

Poi è arrivata la richiesta di collegare Gmail attraverso un target chiamato Composio. Il problema non è solo tecnico, ma concettuale: non viene spiegato chiaramente perché un software che si presenta come locale debba passare da una terza parte esterna per accedere alle mail. Per me questa è una soglia di fiducia importante, e senza una spiegazione trasparente il risultato è un semplice “no”.

Skip sì, utilità poca

C’è un pulsante tipo “skip for now”, quindi in teoria si può andare avanti anche senza concedere tutto subito. In pratica bisogna insistere un po’, ma alla fine si entra davvero nell’app.

Il punto è un altro: se rifiuti di dare accesso a terze parti, OpenHuman resta davvero utile? Questa è la domanda centrale. Perché le funzioni più interessanti sembrano vivere proprio nel punto di incontro tra app locale, account cloud e servizi esterni. Se togli quella parte, resta un guscio molto meno significativo rispetto a quanto il progetto promette.

Ollama, Open WebUI e OpenRouter: altre prove fallite

A questo punto ho provato a portare il tutto sul terreno più favorevole possibile: accesso LLM locale via Ollama, poi Open WebUI come eventuale router/proxy, e infine OpenRouter per testare anche una strada cloud.

Il risultato è stato sempre negativo. Con Ollama non arrivava nessuna risposta in chat e ollama ps non mostrava modelli caricati. Con Open WebUI, usando impostazioni che con altre applicazioni funzionano correttamente, il backend restava silenzioso. Con OpenRouter non è cambiato nulla: le richieste non apparivano neppure nei log.

Questo è stato probabilmente il segnale più chiaro di tutti. Non si tratta di un singolo provider da sistemare o di una configurazione da rifinire. Il problema sembra stare nel modo in cui OpenHuman orchestra il tutto: integrazione, routing, backend, richieste. Se la pipeline non produce neppure tracce nei log, la sensazione è che la superficie sia più avanzata della sostanza.

Perché tante stelline?

La domanda, a questo punto, viene naturale: come fa un software così approssimativo a ottenere tante stelline su GitHub?

La risposta probabilmente non è misteriosa: oggi molti progetti AI vendono prima l’idea e solo dopo il prodotto. Bastano un README convincente, una roadmap ambiziosa, qualche schermata accattivante e un paio di video ben fatti per generare entusiasmo. In molti casi il pubblico non prova davvero il software in scenari normali, oppure lo fa per pochi minuti in condizioni ideali.

OpenHuman mi sembra rientrare proprio in questa categoria: molto forte sul piano narrativo, molto più debole nella prova concreta. E quando il marketing corre parecchio avanti rispetto alla maturità reale del codice, le stelline diventano un indicatore meno affidabile di quanto sembri.

Verdetto attuale

Per ora la valutazione è negativa. Non perché il progetto sia “senza idea”, ma perché l’idea è venduta come se fosse già matura, mentre nella pratica l’esperienza è fragile, poco trasparente e inadatta a un uso sereno.

Il test su Fedora in VM è fallito. Il test su Windows è partito ma ha introdotto dubbi sostanziali sulla privacy e sulle dipendenze cloud. I tentativi con Ollama, Open WebUI e OpenRouter non hanno migliorato il quadro. Il risultato complessivo è un software che promette molto, ma che al momento convince poco.

Disinstallerò OpenHuman e disconnetterò l’account. Per ora, almeno nel mio uso, resta un progetto interessante da osservare, ma non ancora uno strumento davvero affidabile.

Ma ultimamente mi sono fatto una domanda: ha ancora senso usare N8N nel 2026, ora che gli strumenti di codifica AI sono diventati così potenti?

L’esperimento

Avevo un workflow N8N che usavo per trascrivere e sintetizzare registrazioni video — niente di esoterico, ma un processo abbastanza articolato: estrazione audio, chiamata a un modello di trascrizione, sintesi con un LLM, output strutturato. Funzionava, ma con i suoi limiti: dimensione massima dei file in ingresso, dipendenza dall’infrastruttura N8N, e quella sensazione di lavorare “dentro una scatola”.

Ho deciso di provare a riscrivere l’intero flusso come programma standalone. Gli strumenti? Gemini CLI come agente di codifica, il JSON del workflow N8N come specifica di partenza, e un prompt abbastanza dettagliato su cosa volessi ottenere.

Il risultato (che mi ha sorpreso)

In poche decine di minuti avevo un programma funzionante da riga di comando. Non un prototipo traballante: un tool che funziona meglio del workflow N8N originale, senza i limiti sulla dimensione dei file e con un controllo molto più diretto su ogni fase del processo.

Ho scelto deliberatamente la CLI perché l’uso che immagino è locale e sporadico — nessun senso di tirar su un’infrastruttura per qualcosa che uso una volta alla settimana. Ma sarebbe stato altrettanto semplice chiedere a Gemini CLI di generare un’app che espone un webservice: il delta di complessità sarebbe stato minimo.

La cosa che mi ha colpito di più non è tanto la velocità, ma quanto sia stato naturale usare il JSON di N8N come prompt implicito. Il workflow descriveva già la logica del processo in modo strutturato; Gemini ha semplicemente tradotto quella struttura in codice Java coerente e funzionante.

Cosa cambia (e cosa no)

N8N rimane uno strumento valido per certi scenari: team non tecnici, integrazioni con decine di servizi SaaS, processi che devono girare su scheduler senza infrastruttura dedicata. Non sto dicendo che sia morto.

Ma per chi sa usare il terminale e ha accesso a un buon agente di codifica AI, il vantaggio principale di N8N — abbassare la barriera tecnica — si è assottigliato enormemente. Il codice generato è leggibile, manutenibile, e non ha i vincoli architetturali di una piattaforma generalista.

Il codice è pubblico

Ho pubblicato tutto su GitHub: codice sorgente, workflow N8N originale e il prompt iniziale che ho passato a Gemini CLI.

github.com/b0sh-net/VideoToMemo

Se vuoi replicare l’esperimento o adattarlo a un tuo caso d’uso, tutto quello che ti serve è lì. Sono curioso di sapere se anche voi avete fatto ragionamenti simili su N8N o su altri strumenti di automazione visuale — scrivetemi nei commenti.

phone-whisper è un’app Android open source che ho sviluppato a partire da un fork di un progetto esistente, riprogettandola per fare una cosa sola ma fatta bene: trascrivere file audio condivisi direttamente sul dispositivo, in modo completamente locale.

Da dove nasce il progetto

Il punto di partenza è stato un progetto open source che sfruttava il riconoscimento vocale via microfono. L’idea di base mi piaceva, ma quello che mi serviva era diverso: volevo poter condividere un file audio da qualsiasi app — WhatsApp, Files, un registratore vocale — e ottenere la trascrizione in pochi secondi, tutto offline.

Ho quindi forkato il progetto e ho iniziato ad adattarlo, usando strumenti di intelligenza artificiale come Gemini CLI e Qwen Code per accelerare il refactoring e la riscrittura delle funzionalità principali. L’AI è stata preziosa per navigare una codebase che non conoscevo a fondo e per generare rapidamente le modifiche necessarie all’integrazione con il sistema di condivisione di Android.

Il debugging: quando la trascrizione locale non funzionava

Qui le cose si sono fatte interessanti. Il sistema di trascrizione locale del progetto originale non funzionava in modo affidabile — o meglio, non funzionava affatto nel mio caso. Dopo varie sessioni di debug, ho capito che la soluzione più stabile era integrare direttamente sherpa-onnx, una libreria di inferenza vocale offline estremamente performante, sviluppata dal team k2-fsa.

Il problema? Non potevo semplicemente aggiungere la dipendenza tramite Gradle come si farebbe normalmente. Ho dovuto includere la libreria direttamente come file .aar all’interno del progetto, per garantire compatibilità e controllo sulla versione esatta utilizzata.

E proprio le versioni sono state un altro grattacapo: l’ultima release di sherpa-onnx al momento dello sviluppo (la v1.12.39) aveva un’interfaccia pubblica diversa rispetto a quella pensata per il progetto originale. Questo ha richiesto ulteriori modifiche ai metodi di comunicazione tra i componenti, ma alla fine tutto ha trovato il suo posto.

Come funziona oggi

La release 0.4.4 è stabile e funzionante. Il flusso d’uso è semplice:

1. Condividi un file audio da qualsiasi app verso phone-whisper
2. L’app avvia la trascrizione in locale, senza connessione internet
3. Ottieni il testo trascritto direttamente sul dispositivo

Per ottenere i migliori risultati con audio in italiano, consiglio di utilizzare il modello Parakeet 0.6B: offre un ottimo equilibrio tra qualità della trascrizione e dimensioni del modello.

Una cosa importante sull’installazione del modello

Il primo avvio richiede il download e l’installazione del modello linguistico, che può richiedere qualche minuto. Non interrompere il processo: farlo potrebbe corrompere l’installazione e rendere l’app non funzionante. Se dovesse succedere, è necessario cancellare i dati dell’applicazione dalle impostazioni di Android per poter ripetere l’installazione da capo.

Conclusioni e link utili

phone-whisper nasce da un’esigenza reale, da un po’ di debugging ostinato e dall’aiuto — sempre più indispensabile — degli strumenti AI per muoversi velocemente in territorio inesplorato. È un progetto piccolo, ma funziona, è privato by design e gira interamente sul tuo telefono.

• Repository GitHub: github.com/b0sh-net/phone-whisper
• Release 0.4.4: github.com/b0sh-net/phone-whisper/releases/tag/0.4.4
• sherpa-onnx: github.com/k2-fsa/sherpa-onnx

Ho qualche dubbio sull’opportunità di pubblicare sullo store ufficiale … dovrei informarmi su burocrazia e costi.

L’Aero Club d’Italia (AECI) mette a disposizione un’applicazione desktop per simulare l’esame di conseguimento dell’attestato VDS (Volo da Diporto o Sportivo). Utile, certo – ma decisamente più comodo avere qualcosa in tasca, da usare anche lontano dalla scrivania. Non a caso esistono già alcune app per smartphone, tutte però a pagamento.

Ho voluto quindi fare un esperimento: quanto tempo ci vuole per replicare le funzionalità dell’app di AECI in formato mobile, usando un modello AI gratuito come strumento di sviluppo?

Il risultato

In circa una giornata di lavoro ho ottenuto un prototipo sostanzialmente funzionante. Lo strumento usato? Qwen 3 Plus, recentemente disponibile gratuitamente su OpenRouter, abbinato a Claude Code.

La qualità del modello è evidente: rispetto a Nemotron 3 Super rappresenta un netto passo avanti in termini di comprensione del contesto e qualità del codice generato. Poterlo usare gratuitamente sembra quasi troppo bello per essere vero – e probabilmente questa finestra non durerà a lungo. Consiglio di sfruttarla finché c’è.

Prova l’app (è open source)

Il codice è disponibile su GitHub: github.com/b0sh-net/vdsexamapp

Chiunque voglia provarla, migliorarla o creare opere derivate è il benvenuto. Il progetto è aperto a contributi e modifiche di ogni tipo.

Ho voluto quindi riprovare con Nemotron-Cascade-2, ma le sue richieste hardware si sono rivelate eccessive per la mia macchina. Incuriosito comunque dall’ecosistema di modelli NVIDIA, ho scoperto che Nemotron 3 Super è disponibile gratuitamente su OpenRouter — e ho deciso di metterlo alla prova con lo stesso compito.

Quasi 21 milioni di token dopo, e con una spesa effettiva di 0$, l’applicazione non è ancora priva di bug. Eppure, in qualche modo, sembra più vicina a qualcosa di concreto rispetto a quanto ottenuto con Qwen3.5. Il dettaglio più incoraggiante? Non si è ancora bloccato su un errore irrisolvibile. Con qualche altra sessione di test e qualche milione di token in più, potrebbe davvero riuscire a chiudere il lavoro.

Resta però evidente una cosa: siamo ancora molto lontani dall’idea romantica di “mi faccio un’app semplice, senza scrivere una riga di codice, in pochi minuti”. Forse ci proverò anche con Claude Sonnet, se mi avanza qualche credito a fine mese.

Il progetto è pubblico: puoi scaricarlo e testarlo sul repository GitHub.

L’impressione è che sì, si possa fare. Il modello configura tutto, scarica i framework, e dietro mio suggerimento si costruisce una lista di task da completare uno alla volta. Gli chiedo poi di riverificare il lavoro svolto, e in circa un quarto d’ora l’applicazione è pronta. In teoria.

Gli chiedo di riverificare tutto…

Il problema? Ha usato una versione del framework non ancora compatibile con Expo Go per i test diretti sul telefono. Da lì è partita una serie infinita di prompt di debug per abbassare la versione e aggiornare tutte le API interne, apparentemente diverse tra una release e l’altra.

Il risultato rimane comunque notevole, soprattutto considerando che tutto è generato da un modello da soli 9 miliardi di parametri, che gira su una scheda video nata per i videogiochi e tutt’altro che all’ultimo grido. Forse se non lo avessi forzato a passare dalla versione 55 alla 54 di React Native me la sarei cavata con meno litigi. Ma il limite vero sembra essere sempre lo stesso: la rifinitura del codice generato. O funziona subito, oppure ci vuole dieci volte il tempo che si impiegherebbe a scriverlo a mano.

Come piccolo aiuto ho agganciato Context7 come MCP server, per evitargli di allucinare le API dei framework — ma con successo solo parziale.

Questa guida documenta il processo completo per configurare correttamente l’inoltro da un dominio custom gestito con Postfix e Webmin verso Gmail, risolvendo i problemi di autenticazione SPF/DKIM che causano il blocco con errore 550 5.7.26.

Il problema: Gmail rifiuta le email inoltrate

Attivando l’inoltro automatico dal proprio server di posta verso Gmail, si riceve quasi immediatamente un bounce con questo errore:

text550-5.7.26 Your email has been blocked because the sender is unauthenticated.
Gmail requires all senders to authenticate with either SPF or DKIM.
DKIM = did not pass
SPF [dominio-originale.com] with ip: [IP-del-tuo-server] = did not pass

La causa è strutturale: quando il server di posta inoltra un messaggio, il mittente nell’envelope (Return-Path) rimane quello originale (es. mittente@dominio-esterno.com), ma l’IP che effettua la consegna è quello del tuo server. Gmail verifica l’SPF del dominio originale contro l’IP del tuo server — e ovviamente fallisce, perché il tuo server non è autorizzato a inviare per conto di domini terzi.

La soluzione: SRS + SPF sul dominio di inoltro

La soluzione completa richiede tre interventi:

1. SRS (Sender Rewriting Scheme) — riscrive il mittente envelope usando il tuo dominio
2. Record SPF sul tuo dominio che autorizzi il tuo IP
3. Record DMARC per migliorare la reputazione del dominio

Step 1: installare e configurare postsrsd

SRS è un meccanismo che riscrive l’indirizzo mittente nell’envelope da mittente@dominio-esterno.com a SRS0=HASH=TT=dominio-esterno.com=mittente@tuo-dominio.com. In questo modo Gmail verifica l’SPF contro il tuo dominio, che puoi controllare.

Installa il demone postsrsd:

bashapt install postsrsd

Durante l’installazione specifica il tuo dominio (es. tuodominio.com). Il file di configurazione si trova in /etc/default/postsrsd. Verifica che i parametri principali siano corretti:

textSRS_DOMAIN=tuodominio.com
SRS_EXCLUDE_DOMAINS=tuodominio.com
SRS_SECRET=/etc/postsrsd.secret

Verifica che postsrsd sia in ascolto sulle porte corrette:

bashss -tlnp | grep postsrsd
# Output atteso:
# LISTEN 0 10 127.0.0.1:10001 ...
# LISTEN 0 10 127.0.0.1:10002 ...

Step 2: configurare Postfix per usare SRS

Aggiungi queste direttive a /etc/postfix/main.cf (in Webmin: Servers → Postfix Mail Server → Edit Config Files):

textsender_canonical_maps = tcp:127.0.0.1:10001
sender_canonical_classes = envelope_sender
recipient_canonical_maps = tcp:127.0.0.1:10002
recipient_canonical_classes = envelope_recipient,header_recipient

Riavvia i servizi:

bashsystemctl restart postsrsd && postfix reload

Step 3: configurare il forwarding in virtual_alias_maps

Il forwarding non deve essere gestito tramite ~/.forward dell’utente locale, perché quel meccanismo bypassa la sender_canonical_map e quindi SRS non viene applicato. La configurazione corretta va in /etc/postfix/virtual.

Per mantenere la consegna locale e inoltrare a Gmail simultaneamente, usa la sintassi multi-destinatario:

textutente@tuodominio.com    utente-locale, destinatario@gmail.com

Aggiorna la mappa e ricarica:

bashpostmap /etc/postfix/virtual
postfix reload

Step 4: aggiungere il record SPF

Se non è già presente, aggiungi un record TXT SPF sul dominio radice (@) nel DNS:

textv=spf1 ip4:IP-DEL-TUO-SERVER mx ~all

Verifica la propagazione con:

bashdig TXT tuodominio.com +short

Step 5: aggiungere il record DMARC

Aggiungi un record TXT per _dmarc.tuodominio.com:

textv=DMARC1; p=none; rua=mailto:admin@tuodominio.com

Il valore p=none abilita la modalità di solo monitoraggio: non blocca nulla, ma comunica a Gmail che il dominio ha una policy DMARC, migliorando la reputazione nel tempo.

Verifica finale

Invia una mail di test verso l’indirizzo che punta al tuo server e controlla i log:

bashjournalctl -u postfix --since "5 minutes ago" | grep -E "gmail|SRS|status"

Nei log di postsrsd dovresti vedere la riscrittura SRS:

textpostsrsd: srs_forward: <mittente@dominio-esterno.com> rewritten as <SRS0=HASH=TT=dominio-esterno.com=mittente@tuodominio.com>

Nei log di Postfix dovresti vedere la consegna andata a buon fine:

textstatus=sent (250 2.0.0 OK ... gsmtp)

Conclusione

La dismissione del POP3 fetch di Gmail costringe a un setup più corretto e moderno, che in realtà è anche più robusto: SRS + SPF + DKIM + DMARC è la configurazione raccomandata per qualsiasi server di posta che faccia forwarding verso provider che applicano strict authentication come Gmail. Una volta configurato, il sistema è completamente trasparente e non richiede manutenzione.