Whisper e Piper self-hosted su una VPS

Trascrizione vocale e sintesi vocale self-hosted, in breve

La trascrizione vocale e la sintesi vocale self-hosted (TTS, text to speech) sono il tipo di IA più economico da eseguire su un server di proprietà. La trascrizione usa Whisper tramite il runtime faster-whisper. La sintesi usa Piper. Entrambi funzionano su una normale VPS con CPU, senza alcuna GPU. Il modello Whisper di dimensioni ridotte richiede circa 484 MB di spazio su disco e una voce Piper occupa un singolo file ben al di sotto di 150 MB.

Per questo l'audio è il punto di partenza migliore. Un generatore di immagini self-hosted e la generazione video self-hosted richiedono entrambi una GPU prima di poter essere utilizzati. L'audio no.

Questa guida tratta entrambe le direzioni e il livello che le collega. Whisper converte l'audio in testo. Piper converte il testo in audio. Un server HTTP compatibile con OpenAI davanti a entrambi consente a un client esistente di puntare al tuo server modificando soltanto il base URL.

Tutte le versioni indicate erano aggiornate ad agosto 2026.

Perché faster-whisper e non il pacchetto Whisper di riferimento

Il pacchetto whisper di OpenAI esegue il modello in PyTorch. faster-whisper esegue gli stessi pesi del modello su CTranslate2, un motore di inferenza scritto specificamente per i modelli transformer. I pesi sono identici, quindi anche la trascrizione è identica. La differenza riguarda interamente il runtime.

CTranslate2 quantizza i pesi durante il caricamento. Per questo compute_type="int8" è un solo argomento e non richiede un passaggio di conversione separato. Inoltre, non dipende da PyTorch. pip install faster-whisper installa CTranslate2, un tokenizer e PyAV per la decodifica audio. Di conseguenza, l'ambiente virtuale occupa alcune centinaia di megabyte invece di diversi gigabyte. Su un VPS con un disco da 40 GB, questa differenza determina se lo spazio disponibile è sufficiente o limitato.

Questi sono i dati pubblicati dal progetto per il modello small su CPU. Il benchmark trascrive 13 minuti di audio usando 8 thread su un Intel Core i7-12700K. La colonna x_realtime è il rapporto tra questi 13 minuti e il tempo misurato: 7.6 indica che una registrazione di 13 minuti è stata completata in poco più di 1 minuto e 40 secondi.

[
  {
    "label": "openai/whisper, fp32",
    "x_realtime": 1.9,
    "seconds": 418,
    "memory_mb": "2,335"
  },
  {
    "label": "whisper.cpp, fp32",
    "x_realtime": 6.2,
    "seconds": 125,
    "memory_mb": "1,049"
  },
  {
    "label": "faster-whisper, fp32",
    "x_realtime": 5.0,
    "seconds": 157,
    "memory_mb": "2,257"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 7.6,
    "seconds": 102,
    "memory_mb": "1,477"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 15.3,
    "seconds": 51,
    "memory_mb": "3,608"
  }
]

La seconda riga va interpretata correttamente. Con fp32, whisper.cpp è più veloce di faster-whisper su questa CPU: 6.2x contro 5.0x. Inoltre, usa meno della metà della memoria. È la stessa famiglia ggml alla base di llama.cpp per lo stack LLM locale. faster-whisper diventa più veloce quando si attivano int8 e il batching, raggiungendo 15.3x, e per ottenere questo risultato usa 3,608 MB di RAM. Quindi: scegli faster-whisper per l'API Python e il batching; scegli whisper.cpp quando la RAM è il vincolo che non puoi modificare.

La prima riga è il punto centrale di questa sezione. Il pacchetto di riferimento raggiunge 1.9x del tempo reale sulla stessa macchina. Questo significa che 1 ora di audio richiede mezz'ora di elaborazione sulla CPU.

Quanto spazio su disco richiedono i pesi dei modelli Whisper?

[
  {
    "label": "tiny",
    "weights_mb": 75.5
  },
  {
    "label": "base",
    "weights_mb": 145
  },
  {
    "label": "small",
    "weights_mb": 484
  },
  {
    "label": "medium",
    "weights_mb": "1,530"
  },
  {
    "label": "large-v3",
    "weights_mb": "3,090"
  }
]

Queste sono le conversioni pubblicate da CTranslate2, in float16. È importante notare cosa compute_type="int8" non fa: non riduce le dimensioni del download. I pesi vengono scaricati in float16 e CTranslate2 li quantizza in memoria al caricamento. Di conseguenza, large-v3 occupa 3,090 MB su disco sia quando viene eseguito in float16 sia quando viene eseguito in int8. int8 riduce l'uso della RAM e migliora la velocità, ma non riduce lo spazio su disco.

I modelli vengono scaricati al primo utilizzo in ~/.cache/huggingface/hub. Su un VPS con un volume root di dimensioni ridotte, indirizza questa directory verso un percorso con spazio sufficiente usando l'argomento download_root o la variabile d'ambiente HF_HOME. In caso contrario, la prima esecuzione può riempire il disco e il processo può terminare durante il download.

Installare faster-whisper senza compromettere il Python di sistema

Ubuntu 24.04 e Debian 13 contrassegnano il Python di sistema come gestito esternamente. L'esecuzione di pip install faster-whisper al di fuori di un ambiente virtuale si interrompe immediatamente con:

error: externally-managed-environment

È il sistema di gestione dei pacchetti che protegge i file di proprietà di apt. Utilizzare un ambiente virtuale.

sudo apt update
sudo apt install -y python3-venv ffmpeg
python3 -m venv ~/stt
~/stt/bin/pip install --upgrade pip
~/stt/bin/pip install faster-whisper==1.2.1

La versione 1.2.1 è la release corrente, pubblicata a ottobre 2025. faster-whisper decodifica l'audio tramite PyAV, che include le proprie librerie ffmpeg. Per questo può leggere file mp3 o m4a senza un binario ffmpeg separato. Il pacchetto ffmpeg precedente serve per l'elaborazione video descritta più avanti in questa guida.

Verificare l'installazione prima di scaricare tre gigabyte di modelli:

~/stt/bin/python -c "from faster_whisper import WhisperModel; print('ok')"

Una riga con ok indica che i wheel sono stati installati correttamente. Un ImportError che indica ctranslate2 significa che il wheel per la propria architettura non è stato installato. Questo accade nelle immagini ARM a 32 bit.

Trascrivere una registrazione di una riunione o una nota vocale

Salvare il seguente contenuto in transcribe.py:

from faster_whisper import WhisperModel

model = WhisperModel("small", device="cpu", compute_type="int8", cpu_threads=4)
segments, info = model.transcribe("meeting.m4a", beam_size=5, vad_filter=True)

print("language: %s (%.2f)" % (info.language, info.language_probability))
for segment in segments:
    print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))

Eseguirlo con ~/stt/bin/python transcribe.py. Al primo avvio vengono scaricati i pesi, quindi per qualche tempo non viene visualizzato nulla. In seguito, il modello viene caricato dalla cache in pochi secondi.

segments è un generatore, quindi la trascrizione non inizia finché non si esegue un'iterazione su di esso. Si misura la durata della chiamata transcribe(), si osserva che restituisce immediatamente il controllo e si pensa che ci sia un problema. Non c'è alcun problema. L'elaborazione avviene nel ciclo.

vad_filter=True esegue prima Silero VAD (rilevamento dell'attività vocale) ed elimina i segmenti silenziosi prima che Whisper li elabori. In una registrazione di una riunione con pause lunghe, questo è il principale miglioramento di velocità disponibile, perché Whisper non impiega tempo sull'audio che non contiene parlato. Inoltre, impedisce i cicli con ripetizione di frasi che Whisper produce quando riceve silenzio e cerca di individuare parole al suo interno.

Impostare cpu_threads sul numero effettivo di core disponibili. Impostarlo su un valore superiore al numero di vCPU rallenta la trascrizione, perché i thread aggiuntivi competono per lo stesso core e lo scheduler deve gestire il costo di ogni cambio di contesto.

Sottotitoli per una libreria Jellyfin

Jellyfin legge i file dei sottotitoli esterni presenti accanto al video e con lo stesso nome. Di conseguenza, Movie (2019).en.srt accanto a Movie (2019).mkv viene visualizzato come traccia in inglese, senza transcodifica e senza ricostruire la libreria.

Estrai prima l'audio. Whisper ricampiona internamente tutto a 16 kHz mono, quindi fornirgli audio già in formato 16 kHz mono riduce il lavoro su entrambi i lati:

ffmpeg -i "Movie (2019).mkv" -vn -ac 1 -ar 16000 -c:a pcm_s16le "Movie (2019).wav"

faster-whisper non include un writer SRT, quindi formatta manualmente i segmenti. Salva questo contenuto come srt.py:

import sys
from faster_whisper import WhisperModel

def ts(seconds):
    ms = int(round(seconds * 1000))
    hours, ms = divmod(ms, 3600000)
    minutes, ms = divmod(ms, 60000)
    secs, ms = divmod(ms, 1000)
    return "%02d:%02d:%02d,%03d" % (hours, minutes, secs, ms)

model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe(sys.argv[1], vad_filter=True)

with open(sys.argv[2], "w", encoding="utf-8") as out:
    for index, segment in enumerate(segments, start=1):
        out.write("%d\n" % index)
        out.write("%s --> %s\n" % (ts(segment.start), ts(segment.end)))
        out.write("%s\n\n" % segment.text.strip())

Poi percorri la libreria:

for f in /srv/media/films/*.mkv; do
  ffmpeg -nostdin -y -i "$f" -vn -ac 1 -ar 16000 -c:a pcm_s16le "${f%.mkv}.wav"
  nice -n 15 ~/stt/bin/python srt.py "${f%.mkv}.wav" "${f%.mkv}.en.srt"
  rm -f "${f%.mkv}.wav"
done

-nostdin non è un elemento decorativo. Senza questa opzione, ffmpeg legge dallo standard input del loop, consuma il resto dell'elenco di file e il loop si interrompe dopo un solo film senza mostrare messaggi di errore.

Stima il tempo necessario prima di iniziare. Alla velocità di 7.6x indicata sopra, un film di 100 minuti richiede circa 13 minuti di CPU. Una libreria di cinquanta film richiede quindi un'elaborazione notturna. Su un piano con vCPU condivisa l'elaborazione è ancora più lenta. È questo lo scopo di nice: l'elaborazione dei sottotitoli lascia quindi la precedenza alle altre attività effettivamente eseguite dal server.

Sintesi vocale con Piper

Piper è un motore neurale di sintesi vocale che esegue un modello vocale ONNX sulla CPU. Integra espeak-ng per convertire il testo in fonemi, quindi non è necessario installare un phonemizer separato. La release attuale è la 1.6.0, pubblicata a luglio 2026.

python3 -m venv ~/tts
~/tts/bin/pip install piper-tts==1.6.0
~/tts/bin/python -m piper.download_voices en_US-lessac-medium
~/tts/bin/python -m piper -m en_US-lessac-medium -f test.wav -- 'This is a test.'

download_voices scrive due file nella directory di lavoro: i pesi .onnx e una configurazione .onnx.json che contiene la frequenza di campionamento e l'elenco degli speaker. I due file devono rimanere insieme. Se conservi le voci in una posizione fissa, passa --data-dir a entrambi i comandi, perché in caso contrario il player cerca nella directory di lavoro e non trova una voce che non si trova lì.

Anche -- prima del testo è importante. Senza questo parametro, qualsiasi frase che inizia con un trattino viene interpretata come un'opzione della riga di comando.

Le voci sono disponibili a diversi livelli di qualità. Una voce inglese di qualità media occupa circa 60 MB, mentre una di qualità alta occupa circa il doppio. Una qualità maggiore implica un modello più grande e un maggiore uso della CPU per ogni secondo di parlato, non uno speaker diverso.

Non richiamare la CLI in un ciclo. Il modello viene caricato a ogni esecuzione e, per una frase breve, il caricamento del modello rappresenta la parte principale del costo. Avvia invece il server HTTP:

~/tts/bin/pip install 'piper-tts[http]==1.6.0'
~/tts/bin/python -m piper.http_server -m en_US-lessac-medium --host 127.0.0.1 --port 5000

curl -X POST -H 'Content-Type: application/json' \
  -d '{ "text": "This is a test." }' \
  -o test.wav localhost:5000/synthesize

Se ottieni un test.wav riproducibile, il servizio funziona. Questo endpoint usa il formato proprietario di Piper, non quello di OpenAI, quindi un client che si aspetta /v1/audio/speech non può comunicare con esso. La sezione successiva risolve questo problema.

Mantienilo in esecuzione con un file unit, invece di usare un terminale che chiuderai:

[Unit]
Description=Piper text to speech HTTP server
After=network-online.target

[Service]
User=piper
ExecStart=/home/piper/tts/bin/python -m piper.http_server -m en_US-lessac-medium --data-dir /home/piper/voices --host 127.0.0.1 --port 5000
Restart=on-failure

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now piper lo avvia e lo riavvia dopo un reboot. Se il comando curl precedente non restituisce nulla, journalctl -u piper -n 50 contiene il motivo. Nella maggior parte dei casi manca il file della voce.

La struttura del server compatibile con OpenAI

La maggior parte dei software per la gestione dell'audio utilizza già l'API audio di OpenAI: una richiesta POST multipart a /v1/audio/transcriptions per un file, una richiesta POST JSON a /v1/audio/speech per una frase. È sufficiente pubblicare direttamente questi due endpoint; sul client occorre modificare soltanto l'URL di base.

Speaches è un server che gestisce entrambe le direzioni. Usa faster-whisper per la trascrizione e Piper o Kokoro per la sintesi vocale, esponendoli tramite gli endpoint OpenAI. La release attuale è v0.9.0-rc.3, pubblicata a dicembre 2025. Il progetto non ha ancora raggiunto la versione 1.0, quindi blocca il tag dell'immagine e leggi le note di rilascio prima di eseguire un aggiornamento.

curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.yaml
curl --silent --remote-name https://raw.githubusercontent.com/speaches-ai/speaches/master/compose.cpu.yaml
export COMPOSE_FILE=compose.cpu.yaml
docker compose up --detach

La configurazione con un singolo container è adatta se preferisci non mantenere file compose:

docker run --rm --detach --publish 8000:8000 --name speaches \
  --volume hf-hub-cache:/home/ubuntu/.cache/huggingface/hub \
  ghcr.io/speaches-ai/speaches:latest-cpu

Il volume denominato è l'elemento che viene spesso omesso. Senza questo volume, la cache dei modelli resta nel container. A ogni riavvio vengono quindi riscaricati gigabyte di pesi prima che il server possa rispondere alla prima richiesta.

Per la sintesi vocale è necessario scaricare una voce prima che /v1/audio/speech possa rispondere:

uvx speaches-cli model download speaches-ai/Kokoro-82M-v1.0-ONNX

Dopo questa operazione, qualsiasi client OpenAI funziona modificando l'URL di base:

from pathlib import Path
from openai import OpenAI

openai = OpenAI(base_url="http://localhost:8000/v1", api_key="cant-be-empty")
res = openai.audio.speech.create(
    model="speaches-ai/Kokoro-82M-v1.0-ONNX",
    voice="af_heart",
    input="Hello, world!",
    response_format="mp3",
    speed=1,
)
with Path("output.mp3").open("wb") as f:
    f.write(res.response.read())

Il segnaposto api_key è obbligatorio perché la libreria client OpenAI rifiuta di inviare una richiesta senza questo valore. Il server ignora il valore finché non configuri una chiave reale.

vox-box è l'altro progetto che vale la pena citare. È un pacchetto Python, non un container, e pubblica gli stessi endpoint usando Whisper, FunASR, Bark, Dia o CosyVoice. La versione attuale è 0.0.21, pubblicata a dicembre 2025, e richiede Python 3.10 o versioni successive.

python3 -m venv ~/voice
~/voice/bin/pip install vox-box==0.0.21
~/voice/bin/vox-box start --huggingface-repo-id Systran/faster-whisper-small \
  --data-dir ~/voice/data --host 127.0.0.1 --port 8010

L'esempio fornito dal progetto associa il servizio alla porta 80, che richiede root. Su un server che esegue anche altri servizi, è preferibile usare una porta alta dietro un reverse proxy. vox-box start accetta un solo modello. Per gestire entrambe le direzioni servono quindi una seconda istanza su una seconda porta e l'id del repository del modello vocale.

Chiedi al server quali modelli ha caricato, quindi usa quell'id nel campo model:

curl http://127.0.0.1:8010/v1/models

curl http://127.0.0.1:8010/v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F file="@voice-note.m4a" \
  -F model="faster-whisper-small"

Un corpo JSON del tipo {"text": "..."} indica che l'intero percorso funziona. Un errore 404 sul nome del modello significa che hai fatto un'ipotesi invece di leggere l'output di /v1/models.

Nessuno di questi server abilita l'autenticazione per impostazione predefinita. Associali a 127.0.0.1 e raggiungili tramite una VPN o un reverse proxy che richieda le credenziali. Un /v1/audio/transcriptions aperto su un IP pubblico fornisce CPU gratuitamente a chiunque lo trovi, e prima o poi lo troverà.

Un front end vocale per un assistente self-hosted

Quando entrambe le direzioni rispondono tramite percorsi OpenAI, un front end di chat può gestirle. Open WebUI e le relative alternative accettano nelle impostazioni un base URL compatibile con OpenAI per l'audio. In questo modo un unico server può eseguire un LLM locale con Ollama e chiudere il ciclo vocale a entrambe le estremità.

Considerate la latenza in modo realistico, perché questi tre passaggi vengono eseguiti uno dopo l'altro sugli stessi core. Una domanda di 10 secondi richiede circa 1.3 secondi per la trascrizione, al valore di 7.6x indicato sopra, prima ancora che il modello abbia letto un singolo token. Aggiungete la generazione dei token sulla CPU e il round trip diventa abbastanza lento da far pensare ai tester che il servizio sia bloccato. La trascrizione batch è agevole sulla CPU. La conversazione no, ed è a questo punto che un VPS con GPU inizia a giustificare il costo.

Quando vale davvero la pena usare la GPU?

[
  {
    "label": "openai/whisper, fp16",
    "x_realtime": 5.5,
    "seconds": 143,
    "memory_mb": "4,708"
  },
  {
    "label": "faster-whisper, fp16",
    "x_realtime": 12.4,
    "seconds": 63,
    "memory_mb": "4,525"
  },
  {
    "label": "faster-whisper, int8",
    "x_realtime": 13.2,
    "seconds": 59,
    "memory_mb": "2,926"
  },
  {
    "label": "faster-whisper, int8, batch 8",
    "x_realtime": 48.8,
    "seconds": 16,
    "memory_mb": "4,500"
  }
]

Con la GPU, il modello large in int8 raggiunge 13.2x la velocità reale usando 2,926 MB di VRAM, mentre l'elaborazione in batch raggiunge 48.8x. Prestare attenzione a ciò che i due grafici non mostrano. Usano modelli diversi: le righe della GPU si riferiscono a large-v2, quelle della CPU a small. La GPU non rende il modello small sei volte più veloce. Rende utilizzabile il modello più accurato.

Un piano vCPU condiviso non raggiungerà i valori della CPU. Quel benchmark disponeva in esclusiva di 8 thread su un potente processore desktop. Considera 7.6x un limite massimo, quindi misura il tuo server con time usando una registrazione reale prima di basarci qualsiasi progetto.

Quattro regole pratiche che trovano conferma nell'uso quotidiano:

• Trascrizione occasionale delle proprie registrazioni: CPU, small, int8. Sono sufficienti 2 vCPU dedicati.
• Elaborazioni batch notturne, ad esempio la generazione di sottotitoli: CPU, small o medium, int8, eseguite tramite nice.
• Qualsiasi attività interattiva o l'elaborazione di un'intera libreria in una sera: GPU.
• Piper: sempre CPU. Un modello vocale di queste dimensioni trae quasi nessun vantaggio da una GPU.

Se vuoi capire quali altre attività può gestire lo stesso hardware, la questione più ampia dei modelli AI che puoi eseguire in self-hosting descrive le dimensioni che rientrano o non rientrano nelle risorse disponibili.

Modalità di errore, con le stringhe visualizzate

error: externally-managed-environment durante l'installazione. Python di sistema è protetto dalla distribuzione. Crea un ambiente virtuale come mostrato sopra.

Incompatibilità cuDNN su un host con GPU. L'errore è simile al seguente:

Unable to load any of {libcudnn_ops.so.9.1.0, libcudnn_ops.so.9.1, libcudnn_ops.so.9, libcudnn_ops.so}
Invalid handle. Cannot load symbol cudnnCreateTensorDescriptor

CTranslate2 4.5.0 e versioni successive richiedono cuDNN 9 per CUDA 12, ma sull'host è installato cuDNN 8. Installa cuDNN 9 oppure blocca il runtime precedente con pip install --force-reinstall ctranslate2==4.4.0. Esegui una sola delle due operazioni. Eseguirle entrambe riproduce il problema iniziale.

This CTranslate2 package was not compiled with CUDA support indica un errore diverso, ma con sintomi simili. Il wheel installato è la build solo CPU. Ricrea l'ambiente virtuale sull'host con GPU e lascia che pip scelga nuovamente il wheel.

Frasi ripetute nella trascrizione. Una frase ripetuta dieci volte indica quasi sempre che silenzio o musica sono stati decodificati come parlato. Attiva prima vad_filter=True. Se il problema persiste, ascolta il segmento: un audio quasi silenzioso non fornisce a Whisper elementi sufficienti per stabilire il contesto e il modello ripete l'ultima ipotesi considerata attendibile.

Lingua rilevata in modo errato. Whisper esegue la stima usando soltanto i primi 30 secondi. Un valore info.language_probability molto inferiore a 1.0 indica che la stima non è affidabile. Questo accade quando la registrazione inizia con musica o con voci sovrapposte. Usa language="en" quando conosci già la lingua.

Il processo stampa Killed e si arresta. È l'oom killer del kernel. dmesg mostrerà la riga oom-kill corrispondente. large-v3 richiede più di 3 GB soltanto per i pesi, prima di allocare la memoria di lavoro. Su un VPS da 2 GB, small con int8 è il modello più grande utilizzabile.

Piper non trova la voce. Il player cerca nella directory di lavoro, a meno che non venga passato --data-dir. Esegui ls sulla directory prevista e verifica che siano presenti sia .onnx sia .onnx.json, perché la mancanza di uno dei due causa l'errore tanto quanto la mancanza di entrambi.

FAQ

Posso eseguire la conversione da voce a testo su un VPS con la sola CPU?

Sì, e per l'elaborazione batch è la scelta più sensata. Usando faster-whisper con il modello small a int8, il benchmark pubblicato dal progetto trascrive 13 minuti di audio in 102 secondi su 8 thread di un i7 desktop, circa 7.6x rispetto al tempo reale, con 1,477 MB di RAM. Un piano con vCPU condivisa è più lento, quindi misura le prestazioni del tuo server. La sintesi vocale con Piper è ancora più semplice e non richiede una GPU in nessun caso.

Quale dimensione del modello Whisper devo usare?

Inizia con small a int8. Occupa 484 MB su disco e gestisce bene il parlato registrato e chiaro. Passa a medium quando gli accenti o il rumore di fondo causano errori che non puoi accettare, e a large-v3 solo quando l'accuratezza è più importante di ogni altra cosa, perché richiede 3,090 MB di spazio su disco e oltre 3 GB di memoria. All'estremo opposto, tiny con i suoi 75.5 MB è utile per il rilevamento della lingua e per testare una pipeline, ma non per trascrizioni destinate alla lettura.

Perché faster-whisper è più veloce del pacchetto Whisper originale?

Il modello è lo stesso. Il runtime no. Il pacchetto di riferimento esegue Whisper in PyTorch, mentre faster-whisper usa gli stessi pesi su CTranslate2, un motore progettato per l'inferenza dei transformer che quantizza i pesi al caricamento e non richiede l'installazione di PyTorch. Nel benchmark CPU pubblicato, il pacchetto di riferimento raggiunge 1.9x rispetto al tempo reale, contro 7.6x di faster-whisper a int8, usando meno memoria.

Perché la mia trascrizione ripete continuamente la stessa frase?

Whisper sta interpretando il silenzio o la musica come parlato e riprende la sua ultima ipotesi considerata affidabile. Imposta vad_filter=True nella chiamata transcribe(), che esegue prima il rilevamento dell'attività vocale con Silero e rimuove i tratti di silenzio prima che il modello li elabori. Se la ripetizione continua, controlla il livello dell'audio: una registrazione quasi completamente silenziosa non fornisce al modello informazioni utili.

Come posso ottenere un endpoint audio compatibile con OpenAI sul mio server?

Esegui un server che implementi POST /v1/audio/transcriptions e POST /v1/audio/speech, quindi indirizza il client verso di esso usando un nuovo URL di base. Speaches è un'opzione: viene distribuito come immagine container con una build per CPU e usa faster-whisper per la trascrizione e Piper o Kokoro per la sintesi vocale. Un'altra opzione è vox-box, installato con pip install vox-box e avviato con vox-box start --huggingface-repo-id, che espone un solo modello per processo. Nessuna delle due soluzioni abilita l'autenticazione per impostazione predefinita, quindi associa il servizio a localhost e posiziona davanti un proxy o una VPN.