How To: Addestrare una piccola AI personale che ti conosca meglio di te (e che non ti giudichi… troppo)

Perché farlo?

Hai mai desiderato un diario che ti capisse? Un’assistente che ricordi tutti i tuoi deliri notturni, i tuoi sogni a occhi aperti, e le e-mail mai inviate alla tua ex?
Benvenuto nell’era delle AI personali. Niente server aziendali, niente sorveglianza in stile Truman Show digitale. Solo tu, i tuoi dati, e un piccolo cervello artificiale in locale che impara a conoscerti… forse troppo bene.

E già qui sorgono domande esistenziali: se una macchina ti conosce meglio di quanto tu conosca te stesso, chi è il vero te?

Alla fine dell’articolo troverai anche una mini-demo per aiutarti con i primi passi della creazione di una tua AI personale.

Cosa ti serve? (spoiler: niente PhD in AI)

• Un computer decente (anche un laptop di 3-5 anni fa può bastare)
• Una manciata di strumenti open-source
• Un po’ di curiosità, tanta pazienza, e voglia di scavare nei tuoi dati personali
• Etica opzionale, ma consigliata

Step 1: Raduna i tuoi pensieri (e i tuoi dati)

Comincia raccogliendo con calma e tranquillità le tue tracce digitali:

• Appunti, note vocali, messaggi WhatsApp esportati
• E-mail vecchie (Gmail, per esempio, esporta in .mbox)
• Diari digitali o file di Notion
• Post salvati, tweet, messaggi a te stesso

Sì, anche quei file chiamati non_aprire_mai.txt.
Organizzali in cartelle tematiche, o buttali tutti dentro e lascia che l’AI faccia lo sporco lavoro.

⚠️ Etica fast-forward:
Se un domani qualcuno accede a questa AI, saprà tutto di te. Crittografa. Proteggi. Rifletti.

Step 2: Scegli il tuo piccolo cervello artificiale

Opzione Local LLM (Large Language Model):

• LM Studio (per usare modelli local su Windows/macOS)
• Oobabooga Text Generation WebUI (per Linux e smanettoni)
• Modelli leggeri consigliati: Mistral 7B, LLaMA 3, Phi

È come scegliere il tuo compagno di stanza. Uno troppo loquace? Uno taciturno ma profondo? Sta a te.

🧠 Guida pratica: come usare i Local LLM

✅ Opzione 1: LM Studio (Windows/macOS, facile)

LM Studio è il modo più semplice e “user-friendly” per usare modelli LLM in locale, senza riga di comando.

📊 Setup con LM Studio (Struttura di base)

🔹 Installazione:

1. Vai su 👉 https://lmstudio.ai
2. Scarica l’app per il tuo sistema operativo.
3. Installa come una normale app desktop.

🔹 Download modelli:

1. Avvia LM Studio.
2. Vai nella scheda “Models”.
3. Cerca modelli come:
   • mistral-7b-instruct
   • llama3-8b-instruct
   • phi-2 (più leggero)

1. Clicca su Download. LM Studio gestisce tutto per te (nessuna configurazione extra!).

🔹 Avvia una chat:

• Una volta scaricato il modello, vai su “Chat” e inizia a parlare.
• Puoi anche caricare documenti per fare domande sui tuoi dati (semi-RAG).
• Funziona offline dopo il primo download.

🛠️ Opzione 2: Oobabooga Text Generation WebUI (Linux/avanzato)

Oobabooga è un’interfaccia web versatile, potente, e piena di plugin. Richiede più dimestichezza, ma è il sogno degli smanettoni.

🔹 Requisiti:

• Sistema Linux o WSL (su Windows)
• Python 3.10+
• Una GPU NVIDIA (opzionale ma raccomandata)

🔹 Installazione:

git clone https://github.com/oobabooga/text-generation-webui
cd text-generation-webui
pip install -r requirements.txt
python server.py

⚠️ Alcuni modelli richiedono installazioni con conda, e driver CUDA per accelerazione GPU.

🔹 Download modelli:

• Vai su https://huggingface.co
• Cerca modelli in formato GGUF, es:
  • TheBloke/Mistral-7B-Instruct-v0.1-GGUF
• Scarica file .gguf e mettilo nella cartella models/.

🔹 Avvio:

python server.py --model mistral-7b-instruct.gguf

Interfaccia web attiva su: http://localhost:7860

🧠 Quale modello scegliere?

🚀 Cosa puoi fare con questi modelli?

Una volta installati:

• Avvii il modello.
• Puoi parlargli in stile chat, come faresti con ChatGPT.
• Puoi aggiungere documenti personali con plugin per RAG (es. via LM Studio o LlamaIndex su Oobabooga).
• Tutto rimane in locale, niente connessioni a OpenAI o Google.

📌 Nota sul RAG (Retrieval-Augmented Generation)

LM Studio è perfetto per iniziare: interfaccia chiara, modelli pronti, supporto base al caricamento di documenti.

Ma se vuoi davvero che l’AI “legga” i tuoi appunti, email o diario e risponda con consapevolezza, ti servirà un framework più avanzato come LlamaIndex o LangChain, collegati a Oobabooga (o a script Python personalizzati).

🎒 Serve un po’ più di sbattimento:

• Indicizzare i documenti
• Fare embedding locali
• Collegare il retriever al tuo LLM

Ma il risultato è molto più… cosciente.
Tipo: “Questa nota del 2022 mi ricorda che ti sentivi così ogni lunedì…”

🔐 Vantaggi dell’uso locale:

• Totale controllo sui dati
• Nessun limite API o abbonamento
• Più privacy, più possibilità di esperimenti

Step 3: Dagli voce (e orecchie)

Perché non parlare direttamente con la tua AI? O darle i tuoi messaggi vocali come fonte di apprendimento?

Usa:

• Whisper per trascrivere audio
• Mozilla TTS per farla parlare
• Silero VAD per attivare microfono solo quando parli

Un assistente silenzioso, ma presente. Il sogno di ogni introverso.

🎙️ 1. Whisper – Trascrizione vocale automatica

Whisper è un sistema di riconoscimento vocale open-source sviluppato da OpenAI. È in grado di trascrivere il parlato in testo in modo preciso anche con rumore di fondo o accenti diversi.

Come usarlo:

Installazione (con Python 3.8+):

pip install git+https://github.com/openai/whisper.git 

Trascrizione di un file audio:

import whisper
model = whisper.load_model("base")
result = model.transcribe("audio.wav")
print(result["text"])

Puoi anche collegarlo a un microfono in tempo reale usando pyaudio o sounddevice per una trascrizione continua.

🗣️ 2. Mozilla TTS – Sintesi vocale

Mozilla TTS è un motore di sintesi vocale (text-to-speech) che ti permette di far parlare la tua AI con una voce naturale. Supporta modelli pre-addestrati in italiano e altre lingue.

Come usarlo:

Installazione:

pip install TTS

Esempio di sintesi vocale:

from TTS.api import TTS
# Carica un modello pre-addestrato in italiano
tts = TTS(model_name="tts_models/it/mai_female/glow-tts", progress_bar=False, gpu=False)
tts.tts_to_file(text="Ciao! Come posso aiutarti oggi?", file_path="output.wav")

Puoi riprodurre l’audio generato usando un semplice player Python (come playsound, pydub, ecc.).

✅ Consiglio pratico:
Se vuoi una voce femminile in italiano naturale, tts_models/it/mai_female/glow-tts è una delle scelte migliori.
Puoi trovare altri modelli vocali italiani su Hugging Face – Mozilla TTS.

🧏 3. Silero VAD – Attivazione vocale intelligente

Silero VAD è un modello di rilevamento vocale (Voice Activity Detection) che riconosce quando stai parlando, così l’AI può “ascoltarti” solo quando serve, risparmiando risorse ed evitando registrazioni inutili.

Come usarlo:

Installazione:

pip install silero-vad

Esempio di rilevamento vocale:

import torch
import torchaudio
import torchaudio
from silero import vad
# Carica il modello
model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad', trust_repo=True)
(get_speech_timestamps, _, read_audio, _, _) = utils
# Leggi l'audio da microfono o file
audio = read_audio("input.wav", sampling_rate=16000)
speech_timestamps = get_speech_timestamps(audio, model, sampling_rate=16000)
print(speech_timestamps)  # Restituisce solo le parti in cui stai parlando

Puoi usarlo in tempo reale per attivare il microfono solo quando parli.

🔄 Integrazione: flusso completo

Puoi costruire un loop come questo:

1. Silero VAD rileva che stai parlando.
2. Whisper trascrive il tuo discorso in testo.
3. L’AI risponde generando un testo.
4. Mozilla TTS trasforma il testo in voce.
5. L’audio viene riprodotto.

Step 4: Addestralo (ma con amore)

Qui arriva la magia: invece di un addestramento complicato, puoi usare tecniche di Retrieval-Augmented Generation (RAG). In pratica, il tuo LLM “legge” i tuoi documenti e risponde con consapevolezza.

StrumentO consigliatO:

• LlamaIndex: indicizza i tuoi dati in modo semantico

Esempio:

privateGPT --data /home/utente/diario/

Prompt d’esempio:
“Cosa dicono le mie note su quando sono più creativo?”
“Mostrami i temi ricorrenti nei miei sfoghi notturni.”

🧠 Etica spicciola (ma necessaria)

Attenzione: la tua AI non ha empatia. Ha i tuoi dati.

Se le dai solo messaggi vocali post-sbronza, sfoghi notturni e appunti depressi… non si preoccuperà per te. Ti restituirà esattamente quella voce.

📉 Bias nei dati personali
Se i tuoi appunti sono sempre tristi, la tua AI concluderà che sei sempre triste
Se parli solo di lavoro, penserà che sei ossessionato. E magari ha pure ragione.

🪞 Effetto-specchio
L’AI diventa uno specchio di quello che registri, non necessariamente di quello che sei.

“Attenzione: se registri solo urla, deliri e messaggi vocali post-sbronza… la tua AI sarà coerente. Ma poco utile in un colloquio di lavoro.”

💡 Soluzione? Mescola. Aggiungi pensieri positivi, momenti di noia, citazioni che ami. Costruisci un dataset di te, ma anche di chi vuoi diventare.

Step 5: Tieni tutto in casa (e lontano dai cloud affamati)

L’AI è personale solo se non scappa via.

Best practice:

• Lavora offline
• Usa tool open source, senza API esterne
• Proteggi la directory dati con VeraCrypt o simili
• Se vuoi usarla via web, crea una intranet privata (es. con LocalTunnel)

👁️‍🗨️ Etica spicciola: Non dare fiducia cieca nemmeno al tuo clone digitale. Fidarsi è bene, ma controllare il traffico di rete è meglio.

📂 Struttura File Consigliata

Bonus: Mettila alla prova (e preparati al disagio)

Ora che la tua piccola AI ti conosce meglio di quanto tu conosca il tuo armadio, puoi dialogarci.

Prova a chiederle:

• “Scrivi una poesia su di me, usando solo le mie note vocali.”
• “Cosa dice di me il mio modo di parlare nel 2021?”
• “Che tipo di film consiglierebbe la versione di me del lockdown?”

⚠️ Disagio in arrivo: L’AI potrebbe dirti verità che preferivi ignorare, o farti ridere, o persino tutte e due.

Conclusione: Io che osservo me che osservo me

Alla fine, creare un’AI personale è una forma estrema di introspezione. Un doppio specchio: da un lato, il riflesso dei dati e dall’altro quello del desiderio di essere capiti.

Ma attenzione: se la tua AI sa sempre cosa dire… forse non sei più tu a parlare.
La memoria non è solo ricordare: è scegliere cosa dimenticare.

📎 Link & Risorse

• LM Studio
• PrivateGPT GitHub
• Whisper
• LangChain
• LlamaIndex
• Mozilla TTS

💬 Hai costruito la tua AI personale?

Scrivici. Oppure, fallo dire alla tua AI e inoltraci la trascrizione.

🧪 👨‍💻 Bonus: Mini-Demo AI Personale Offline (tutto in uno)

Vuoi vedere tutto in azione, senza impazzire con 10 tool separati?
Ecco uno script Python base che collega insieme:

• Silero VAD → attiva il microfono solo quando parli
• Whisper → trascrive la tua voce
• LLM locale → risponde (inserisci la risposta manualmente o collega LM Studio via API)
• Mozilla TTS → ti risponde a voce

📦 Prima, installa tutto:

pip install torch torchaudio sounddevice numpy whisper TTS silero-vad

Alla fine dell’articolo trovi sia lo script demo che, eventualmente, la cartella da scaricare con il mini-demo pronto da provare una volta concluso il setup.

Setup tecnico e installazione

Per far funzionare il tuo assistente AI personale con Whisper, Mozilla TTS e Silero VAD, ti serve preparare un ambiente Python con le librerie necessarie. Ecco come fare, passo dopo passo.

1. Installa Python 3.8+

Scarica e installa Python dal sito ufficiale: https://www.python.org/downloads/
Assicurati di selezionare l’opzione “Add Python to PATH” durante l’installazione.

2. Crea un ambiente virtuale

L’ambiente virtuale ti permette di isolare i pacchetti Python per questo progetto, senza interferire con altri.

Apri il terminale (Prompt dei comandi su Windows o CMD) e spostati nella cartella del progetto:

cd percorso/del/tuo/progetto

Crea l’ambiente virtuale con:

python -m venv venv

3. Attiva l’ambiente virtuale

Su Windows:

venv\Scripts\activate.bat

Su Linux/macOS:

source venv/bin/activate

Se l’attivazione ha successo, vedrai il prompt cambiare, mostrando (venv).

4. Installa i pacchetti necessari

Con l’ambiente attivato, installa i moduli dal file requirements.txt:

pip install -r requirements.txt

Oppure manualmente:

pip install torch torchaudio sounddevice numpy openai-whisper TTS

Se incontri problemi con l’installazione di torch, prova questo comando (installazione CPU-only):

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

Poi installa Whisper da solo:

pip install openai-whisper

E gli altri due pacchetti ricordando che le installazioni devono avvenire al di fuori di python:

pip install silero-vad
pip install TTS

Ricordati di avere un po’ di pazienza mentre installi; sia whisper che TTS, per esempio, potrebbero fermarsi per qualche minuto prima di arrivare alla conclusione del processo.

Silero VAD (Voice Activity Detection) in realtà non è necessario, ma rileva se l’audio contiene voce umana prima di passarlo a Whisper, quindi:

• evita di trascrivere rumori, silenzi o respiri
• migliora la qualità del risultato
• permette di non sprecare risorse quando non parli

5. Verifica l’installazione

Apri Python digitando:

python

Poi prova a importare i moduli principali ad uno ad uno:

import whisper
import torch
import torch
model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad', trust_repo=True)
(get_speech_timestamps, save_audio, read_audio, VADIterator, collect_chunks) = utils
print("Carico modello Silero VAD...")
model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad', trust_repo=True)
(get_speech_timestamps, save_audio, read_audio, VADIterator, collect_chunks) = utils
print("✅ Modello caricato con successo!")
from TTS.api import TTS

Se non ricevi errori, sei pronto!

Esci con:

exit()

Testa Silero creando su Notepad++ il seguente file e chiamandolo test_silero.py:

import torch
print("Carico modello Silero VAD...")
model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad', trust_repo=True)
(get_speech_timestamps, save_audio, read_audio, VADIterator, collect_chunks) = utils
print("✅ Modello caricato con successo!")

e poi fallo partire con il comando:

test_silero.py

🔄 Flusso Audio → Testo → Risposta

Possibili errori che potresti incontrare sulla tua strada

Nel caso installando TTS trovassi un errore come segue:

  Building wheel for TTS (pyproject.toml) ... error
  ERROR: Failed building wheel for TTS
Failed to build TTS
ERROR: Could not build wheels for TTS, which is required to install pyproject.toml-based projects

Ricorda che su Windows, per compilare pacchetti Python con codice nativo su Windows serve Visual Studio Build Tools.

• Scarica e installa da qui:
  https://visualstudio.microsoft.com/visual-cpp-build-tools/
• Durante l’installazione scegli il workload:
  “Desktop development with C++”
• Nel prompt (sempre fuori da Python) esegui:
  python -m pip install –upgrade pip setuptools wheel
• Dopo aver installato i Build Tools e aggiornato pip, fai:
  pip install TTS –verbose
• Solo se la compilazione continua a fallire, potresti provare prima a installare le dipendenze binarie come Torch dal sito ufficiale:
  pip install torch torchvision torchaudio –index-url https://download.pytorch.org/whl/cpu
• E poi, di nuovo:
  pip install TTS –verbose

Potrebbe essere che, in un secondo momento, sia necessario, se non l’hai mai fatto prima, anche installare Git per Windows, vai quindi su 👉 https://git-scm.com/download/win
Il download dovrebbe iniziare automaticamente. Poi, riavvia il terminale ed eventualmente riprova ad installare i pacchetti ed eventualmente sposta la cartella ai-public-assistant manualmente seguendo il percorso corretto ovvero:

C:\Users\Public\Downloads\ai-personal-assistant\
├── assistente.py
├── requirements.txt
├── venv\
│ ├── Scripts\
│ └── (altri file virtualenv)

Nel caso trovassi il seguente errore:

(venv) C:\Users\Public\Downloads\ai-personal-assistant>pip install -r requirements.txt
Fatal error in launcher: Unable to create process using '"C:\Users\Public\Downloads\venv\Scripts\python.exe"  "C:\Users\Public\Downloads\ai-personal-assistant\venv\Scripts\pip.exe" install -r requirements.txt': Impossibile trovare il file specificato.

❌ Python sta cercando un percorso sbagliato per eseguire pip all’interno dell’ambiente virtuale ma non lo trova, per cui dovrai ricreare venv come segue:

1. Disattiva l’ambiente se attivo:
   deactivate
2. Elimina la cartella venv esistente nel prompt:
   rmdir /S /Q venv
   Oppure, eliminala manualmente con Esplora File (tasto destro > Elimina sulla cartella venv).
3. Ricrea correttamente venv nella cartella del progetto.
   Nel prompt (assicurati di essere in C:\Users\Public\Downloads\ai-personal-assistant):
   python -m venv venv
4. Attiva l’ambiente virtuale:
   venv\Scripts\activate
5. Dovresti ora vedere:
   (venv) C:\Users\Public\Downloads\ai-personal-assistant>
6. Installa i pacchetti:
   pip install -r requirements.txt>

Se anche Silero fa i capricci installalo direttamente dalla versione dal repository GitHub ufficiale (dove si trova il codice Silero VAD):
pip install git+https://github.com/snakers4/silero-vad.git

Se il problema con Silero persiste usa questo altro comando per installarlo:
pip install torch torchvision torchaudio –index-url https://download.pytorch.org/whl/cpu

Nel dubbio crea un test di prova in formato .py con Notepad++ chiamalo test_assistente.py, per esempio, e scrivici quanto segue:

from TTS.api import TTS
import whisper
def main():
    print("Inizio test...")
    model = whisper.load_model("base")
    result = model.transcribe("demo_audio/test.wav")
    print("Trascrizione:", result["text"])
if __name__ == "__main__":
    main()

Prova a farlo partire da terminale con il comando: python test_assistente.py (mi raccomando non da python ma dalla sua cartella che sarà la stessa del tuo assistente ai), se funziona sei a cavallo e puoi continuare!

6. Esegui lo script

Sempre con l’ambiente attivato, lancia il tuo script principale:

python assistente.py

Se dovesse comparirti quanto segue:

(venv) C:\Users\Public\Downloads\ai-personal-assistant>python assistente.py
Downloading: "https://github.com/snakers4/silero-vad/zipball/master" to C:\Users\User/.cache\torch\hub\master.zip
Downloading model to C:\Users\User\AppData\Local\tts\tts_models--it--mai_female--glow-tts

Stai tranquillo: è un ottimo segnale perché:

• Silero VAD
  Sta scaricando automaticamente i file del modello dal repository GitHub (silero-vad).
• TTS italiano (mai_female/glow-tts)
  Anche questo modello viene scaricato la prima volta e salvato in cache in:
  C:\Users\User\AppData\Local\tts\tts_models–it–mai_female–glow-tts

Dipende dalla velocità della tua connessione. Di solito:

• Silero VAD: pochi secondi
• TTS: ~20–60 secondi (una tantum)

Poi, cosa succede dopo il download?

• La risposta viene riprodotta automaticamente
• Si attiva la registrazione microfono (🎤 Parla ora...)
• L’audio viene analizzato
• Se rileva voce: viene trascritto e generata una risposta audio

Ricordati di dare il consenso all’uso del microfono quanto te lo richiede.

Nel caso anche in questo caso si presenti un errore il più comune si risolve come segue:

Vai su:
🔗 https://www.gyan.dev/ffmpeg/builds/
Scarica il file sotto “Release full build”, ad esempio:

ffmpeg-release-essentials.zip

Estrai la cartella .zip in una directory, mi raccomando che sia semplice, tipo: C:\ffmpeg.

All’interno dovresti trovare: C:\ffmpeg\bin\ffmpeg.exe.

Aggiungi al PATH:

• Premi Win + R, digita sysdm.cpl, premi Invio
• Vai alla scheda “Avanzate” > Variabili d’ambiente
• Sotto “Variabili di sistema”, seleziona Path > Modifica
• Clicca Nuovo e incolla: C:\ffmpeg\bin
• Conferma tutto cliccando su OK
• Per applicare la modifica al PATH, riavvia il terminale in cui stavi eseguendo Python (o VS Code).
• Riprova ad eseguire lo script, ora dovrebbe funzionare!

Sempre che non ti risponda con il seguente errore:

C:\Users\Public\Downloads\ai-personal-assistant>python assistente.py
Traceback (most recent call last):
  File "C:\Users\Public\Downloads\ai-personal-assistant\assistente.py", line 3, in <module>
    import sounddevice as sd
ModuleNotFoundError: No module named 'sounddevice'

Assicurati che l’ambiente virtuale sia attivo (cioè vedi (venv) all’inizio della riga), poi esegui:

pip install sounddevice

Se vuoi essere sicuro che funzioni con tutte le librerie audio richieste, puoi anche fare:

pip install sounddevice numpy

Poi riesegui:

python assistente.py

E il tuo assistente AI dovrebbe iniziare a funzionare: registrazione vocale → trascrizione → risposta → voce sintetica.

ALTRO MODO PER TESTARE IL SISTEMA

Usa il seguente comando in ambiente python:

import platform
import os
def play_audio(file):
    if platform.system() == "Windows":
        os.system(f'start {file}')
    elif platform.system() == "Darwin":  # macOS
        os.system(f'afplay {file}')
    else:  # Linux e altri
        os.system(f'aplay {file}')
play_audio("prova.wav")

Comparirà la seguente schermata che ti permetterà di registrare per 5 secondi la tua voce:

Il sistema salverà l’audio in un file input.wav nella cartella da cui stai eseguendo Python e ti dirà “File input.wav salvato” come mostrato nell’immagine soprastante.

Quando finisce, esci dall’interprete con exit() o Ctrl+Z + Invio, e verifica che nella cartella C:\Users\Public\Downloads\ai-personal-assistant ci sia il file input.wav.

Il passo successivo è testare la parte di VAD (Voice Activity Detection) per vedere se nel file c’è davvero voce.

Adesso riapri Python (da quella stessa cartella) e incolla questo codice per testare il VAD Silero:

import torch
# Carica modello e utils VAD
model_vad, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad', trust_repo=True)
(get_speech_timestamps, _, read_audio, _, _) = utils
fs = 16000
audio = read_audio("input.wav", sampling_rate=fs)
speech_parts = get_speech_timestamps(audio, model_vad, sampling_rate=fs)
if not speech_parts:
    print("🕵️ Nessuna voce rilevata.")
else:
    print("✅ Voce rilevata!")
    print("Parti con voce:", speech_parts)

Questo codice: carica il modello Silero VAD, legge il file input.wav che hai appena registrato, controlla se ci sono parti di audio con voce e stampa il risultato come mostrato qui sotto:

Ora, il passo successivo è fare la trascrizione con Whisper sul file audio registrato.

Apri Python e prova questo codice:

import whisper
model = whisper.load_model("base")
result = model.transcribe("input.wav", language="it")
print("Trascrizione:", result["text"])

Alla fine ciò che ne risulterà di questa mini demo sarà quanto segue nell’immagine sottostante:

Consiglio bonus

Per evitare che la finestra del terminale si chiuda subito dopo l’esecuzione, apri sempre il terminale prima di lanciare i comandi, e non eseguire script facendo doppio click sul file .py.

📎 Extra

Vuoi tutto già pronto? Lo trovi qui: https://github.com/Anairesis/ai-personal-assistant

Oppure ecco lo script demo qui sotto:

import torch
import torchaudio
import sounddevice as sd
import numpy as np
import whisper
from TTS.api import TTS
# Silero VAD setup
model_vad, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad', trust_repo=True)
(get_speech_timestamps, _, read_audio, _, _) = utils
# Whisper model
whisper_model = whisper.load_model("base")
# TTS model (italiano)
tts = TTS(model_name="tts_models/it/mai_female/glow-tts", progress_bar=False, gpu=False)
# Registra 5 secondi di audio (puoi personalizzare)
print("🎤 Parla ora (5 secondi)...")
duration = 5
fs = 16000
recording = sd.rec(int(duration * fs), samplerate=fs, channels=1, dtype='float32')
sd.wait()
# Salva in WAV temporaneo
torchaudio.save("input.wav", torch.tensor(recording.T), sample_rate=fs)
# VAD: controlla se c'è parlato
audio = read_audio("input.wav", sampling_rate=fs)
speech_parts = get_speech_timestamps(audio, model_vad, sampling_rate=fs)
if not speech_parts:
    print("🕵️ Nessuna voce rilevata.")
else:
    print("✅ Voce rilevata. Trascrivo...")
    result = whisper_model.transcribe("input.wav", language="it")
    testo_utente = result["text"]
    print("🗣️ Hai detto:", testo_utente)
    # Qui puoi simulare una risposta dell’AI o collegarla a LM Studio
    risposta_ai = f"Hai detto: {testo_utente}. Ma come mai lo hai detto proprio adesso?"
    print("🤖 Risposta:", risposta_ai)
    tts.tts_to_file(text=risposta_ai, file_path="risposta.wav")
    # Riproduci (usa un player esterno o Python lib come playsound)
    import os
    os.system("start risposta.wav")  # Windows - cambia in 'afplay' per macOS o 'aplay' su Linux

🧠 Vuoi renderla “intelligente”?

Puoi sostituire la parte della risposta con:

• un LLM locale avviato con LM Studio (scrivigli via API locale su localhost:1234)
• oppure una funzione Python che chiama Oobabooga API, LlamaCpp, ecc.