Se passi piu' di un'ora alla settimana in riunioni online, hai gia' pensato a una soluzione di trascrizione automatica. Le opzioni a pagamento (Otter.ai, tl;dv, Fireflies) costano dai 10 ai 30 euro al mese per utente e mandano i tuoi audio su server di terze parti. La buona notizia: con Whisper Large V3 di OpenAI puoi trascrivere riunioni di un'ora in circa 5 minuti sul tuo computer, completamente gratis, in italiano impeccabile e con la possibilita' di tradurre in inglese al volo. In questa guida ti mostro come, su Mac e su Windows.

A chi serve, cosa otterrai, prerequisiti

La guida e' per chi vuole un sistema privato e locale per trascrivere riunioni, lezioni, podcast, video di YouTube. Niente account, niente abbonamenti, niente upload. Alla fine avrai uno script che, dato un file audio o video, produce una trascrizione in formato testo, sottotitoli SRT e un riassunto generato da Claude o GPT.

Prerequisiti reali:

  • Mac Apple Silicon (M1/M2/M3/M4) oppure Windows/Linux con almeno 16 GB di RAM. Una GPU NVIDIA dedicata (8+ GB di VRAM) e' un grosso plus ma non indispensabile su Mac.
  • Python 3.10 o 3.11 installato.
  • FFmpeg per gestire i file audio.
  • Spazio disco: circa 3 GB per il modello Large V3.
  • (Opzionale) Una API key di Anthropic o OpenAI per il riassunto automatico.

Quale strumento scegliere fra Whisper, Whisper.cpp e Faster-Whisper

L'ecosistema Whisper ha tre implementazioni principali. Vediamole:

  • openai/whisper (Python, PyTorch): l'originale di OpenAI. Funziona bene ma usa molta memoria. Conviene su GPU NVIDIA o Apple Silicon con Metal Performance Shaders.
  • whisper.cpp di Georgi Gerganov (C++): porting estremamente ottimizzato, gira velocissimo su Mac Apple Silicon e su CPU Intel/AMD recenti. Consigliato se non hai GPU dedicata.
  • faster-whisper di SYSTRAN (Python, CTranslate2): 4x piu' veloce dell'originale Python con la stessa qualita'. Migliore equilibrio per chi sviluppa script in Python e lavora su GPU NVIDIA.

La nostra prima scelta: faster-whisper se hai una GPU NVIDIA o lavori in Python; whisper.cpp se hai un Mac M-series. In entrambi i casi userai il modello Whisper Large V3, l'ultima versione pubblicata da OpenAI nel novembre 2023 e ancora oggi lo stato dell'arte per le lingue europee, italiano compreso.

Procedimento passo-passo: faster-whisper su Mac o Linux

Step 1. Installa FFmpeg e Python se non li hai:

# macOS con Homebrew
brew install ffmpeg python@3.11

# Ubuntu/Debian
sudo apt update && sudo apt install ffmpeg python3.11 python3-pip

Step 2. Crea un ambiente virtuale e installa faster-whisper:

python3.11 -m venv whisper-env
source whisper-env/bin/activate
pip install faster-whisper anthropic

Step 3. Crea il file trascrivi.py con questo contenuto:

from faster_whisper import WhisperModel
import sys, os

audio_file = sys.argv[1]
out_txt = os.path.splitext(audio_file)[0] + ".txt"
out_srt = os.path.splitext(audio_file)[0] + ".srt"

print("Caricamento modello Whisper Large V3...")
model = WhisperModel("large-v3", device="auto", compute_type="auto")

print(f"Trascrizione di {audio_file} in italiano...")
segments, info = model.transcribe(audio_file, language="it", beam_size=5,
                                   vad_filter=True)

with open(out_txt, "w") as f_txt, open(out_srt, "w") as f_srt:
    for i, seg in enumerate(segments, 1):
        f_txt.write(seg.text.strip() + "\n")
        start = f"{int(seg.start//3600):02d}:{int((seg.start%3600)//60):02d}:{seg.start%60:06.3f}".replace(".", ",")
        end   = f"{int(seg.end//3600):02d}:{int((seg.end%3600)//60):02d}:{seg.end%60:06.3f}".replace(".", ",")
        f_srt.write(f"{i}\n{start} --> {end}\n{seg.text.strip()}\n\n")

print(f"Salvato: {out_txt} e {out_srt}")

Step 4. Lancia la trascrizione sul tuo file:

python trascrivi.py riunione_18_maggio.mp3

La prima volta il sistema scarica il modello (circa 3 GB) e poi parte la trascrizione. Su un Mac M2 Pro un'ora di audio in italiano viene trascritta in circa 4-5 minuti. Su una RTX 3060 ancora piu' velocemente.

Procedimento alternativo: whisper.cpp su Mac Apple Silicon

Se preferisci una soluzione zero-Python, whisper.cpp e' un binario veloce e leggero:

git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp
make -j
# scarica il modello large-v3 quantizzato (1,5 GB invece di 3 GB)
sh ./models/download-ggml-model.sh large-v3-q5_0

# converti MP4 o M4A in WAV 16 kHz mono (richiesto da Whisper)
ffmpeg -i riunione.mp4 -ar 16000 -ac 1 -c:a pcm_s16le riunione.wav

# trascrivi
./main -m models/ggml-large-v3-q5_0.bin -f riunione.wav \
       -l it -osrt -otxt -of riunione

Il flag -l it forza l'italiano; -osrt -otxt genera sottotitoli e testo. La versione quantizzata Q5 ha una qualita' indistinguibile dalla full su parlato chiaro e occupa meta' della memoria.

Whisper Large V3 funziona bene sia in Python che in C++; per Mac M-series whisper.cpp e' spesso la scelta piu' veloce.

Aggiungere il riassunto automatico con Claude o GPT-5.5

Una trascrizione di un'ora di meeting e' lunga 8.000-12.000 parole. Pochi avranno tempo di leggerla. Aggiungiamo un riassunto automatico con Claude Sonnet 4.6 (o GPT-5.5).

import anthropic, sys

testo = open(sys.argv[1]).read()
client = anthropic.Anthropic()  # legge ANTHROPIC_API_KEY dall'ambiente

istruzioni = (
    "Sei un assistente per riunioni di lavoro.\n"
    "Riassumi il meeting in massimo 200 parole, poi elenca:\n"
    "1) Decisioni prese.\n"
    "2) Action item con nome del responsabile.\n"
    "3) Eventuali scadenze citate.\n\n"
    "TRASCRIZIONE:\n"
)

msg = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1500,
    messages=[{"role":"user","content": istruzioni + testo}]
)
print(msg.content[0].text)

Salva come riassumi.py, imposta la variabile ANTHROPIC_API_KEY e lancia: python riassumi.py riunione_18_maggio.txt. Un'ora di trascrizione costa circa 5-10 centesimi di token Claude. Con GPT-5.5 Instant il costo e' simile. Se preferisci tenere tutto in locale, puoi usare Ollama con un modello come qwen2.5:32b: il riassunto e' un po' meno raffinato ma totalmente gratis.

Tradurre la trascrizione in inglese

Whisper Large V3 ha una modalita' translate integrata che trasforma il parlato in qualunque lingua direttamente in testo inglese. Basta cambiare il parametro task:

segments, info = model.transcribe(audio_file, task="translate", beam_size=5)

Utile per fornire ai colleghi non italofoni la trascrizione tradotta, oppure per sottotitolare un video. Non e' "transcribe + GPT translate": e' un singolo passaggio fatto da Whisper, piu' veloce e con meno passaggi di latenza.

Errori comuni e soluzioni

  • "CUDA out of memory": la GPU non ha abbastanza VRAM. Imposta compute_type="int8" in faster-whisper o usa il modello large-v3-q5_0 di whisper.cpp.
  • Trascrizione "a chunk" con sovrapposizioni: capita su audio molto rumorosi. Aggiungi vad_filter=True (gia' nel nostro script) per filtrare i silenzi.
  • Errore "Format not supported": converti l'audio in WAV 16 kHz mono prima della trascrizione (vedi comando FFmpeg sopra).
  • Trascrizione in inglese anche se l'audio e' italiano: aggiungi language="it" esplicitamente.

Varianti avanzate e quando NON usare Whisper

Per riunioni con piu' partecipanti e necessita' di sapere chi ha detto cosa, accoppia Whisper con un modello di speaker diarization come pyannote.audio. Per audio in dialetto stretto (napoletano, siciliano, sardo) Whisper Large V3 fa fatica: in quel caso valuta NVIDIA Parakeet o servizi a pagamento. Per audio di altissima qualita' e short-form (note vocali, comandi vocali), il modello medium di Whisper e' sufficiente e gira piu' veloce. Per chi non vuole gestire un'installazione, l'API OpenAI a 0,006 dollari per minuto e' la scelta piu' semplice.

Come proseguire

Una volta automatizzata la trascrizione, l'evoluzione naturale e' un'integrazione con il tuo flusso di lavoro: cartella "Meetings" che monitora nuovi file audio, esegue lo script, salva in Google Drive o Notion, manda il riassunto via Slack. Tutti questi pezzi si possono orchestrare con n8n o con uno script Python schedulato via cron. Su AI Notizie abbiamo gia' pubblicato una guida pratica su n8n per chi vuole assemblare il tutto in un workflow visuale.