Casi d'uso della trascrizione in tempo reale
In questa pagina
Corso aggiornato il 3 novembre 2026 per Voxtral 3, basato sulla guida Migrate from Voxtral 2 di Mistral: i modelli Voxtral 2 (
voxtral-mini-2602,voxtral-mini-transcribe-realtime-2602,voxtral-mini-tts-2603), deprecati il 31 ottobre 2026 e ritirati il 30 aprile 2027, sono sostituiti negli esempi davoxtral-mini-transcribe-3,voxtral-mini-transcribe-realtime-3evoxtral-mini-tts-3-0. Cambiamenti chiave: i timestamp sono solo per segmento (wordrestituisce un errore 400), la diarizzazione in tempo reale è supportata, le impostazioni della sessione in tempo reale sono bloccate dopo il primo chunk audio e gli inputcontext_biassono in formato libero (frasi con spazi). Fonti: Migrate from Voxtral 2 · Speech to Text.
Quattro applicazioni di streaming concrete
Ora hai tutti i mattoni fondamentali: lo stream, il microfono e la regolazione della latenza. Questa lezione li assembla in quattro applicazioni complete: sottotitolaggio in diretta, assistente vocale, dettatura e trascrizione di conferenze, che puoi usare così come sono come punto di partenza. Ognuna illustra un problema che la modalità offline non può risolvere e utilizza un’impostazione di latenza diversa, dandoti una percezione concreta della regolazione discussa in precedenza.
Sottotitolaggio in diretta
Il sottotitolaggio è il caso d’uso in tempo reale più visibile, ma anche il più esigente in termini di presentazione. Trascrivere non basta: devi spezzare il testo in righe brevi, visualizzarne solo due alla volta e scorrere il tutto senza mai dividere una parola a metà. È esattamente ciò che fa la classe seguente. Quando la riga corrente raggiunge la lunghezza massima, trova l’ultimo spazio prima di quel limite e interrompe lì; se non viene trovato alcuno spazio (una parola molto lunga, un URL dettato), taglia alla lunghezza massima invece di far traboccare la riga. L’impostazione di 800 millisecondi riflette la priorità di questo caso d’uso: un testo leggibile è meglio di un testo istantaneo ma spezzato, e il pubblico non noterà questo leggero ritardo.
import asyncio
import os
from mistralai.client import Mistral
from mistralai.client.models import (
AudioFormat,
TranscriptionStreamTextDelta,
TranscriptionStreamDone
)
class LiveCaptioning:
"""Sistema di sottotitolaggio in diretta con gestione delle righe."""
def __init__(self, max_chars_per_line=50, max_lines=2):
self.max_chars = max_chars_per_line
self.max_lines = max_lines
self.current_line = ""
self.lines = []
async def run(self, audio_source):
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
async for event in client.audio.realtime.transcribe_stream(
audio_stream=audio_source,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=800,
):
if isinstance(event, TranscriptionStreamTextDelta):
self._add_text(event.text)
elif isinstance(event, TranscriptionStreamDone):
self._afficher_final()
def _add_text(self, texte):
self.current_line += texte
if len(self.current_line) >= self.max_chars:
pos = self.current_line.rfind(" ", 0, self.max_chars)
if pos > 0:
self.lines.append(self.current_line[:pos])
self.current_line = self.current_line[pos + 1:]
else:
self.lines.append(self.current_line[:self.max_chars])
self.current_line = self.current_line[self.max_chars:]
if len(self.lines) > self.max_lines:
self.lines = self.lines[-self.max_lines:]
self._afficher()
def _afficher(self):
for ligne in self.lines:
print(f" {ligne}")
print(f" {self.current_line}", end="", flush=True)
def _afficher_final(self):
print("\n\n[Sottotitolaggio terminato]")
Assistente vocale interattivo
Un assistente vocale non può permettersi il silenzio. Deve comprendere l’utente mentre parla, altrimenti lascia un vuoto dopo ogni domanda che rivela immediatamente la natura meccanica della risposta. La trascrizione in tempo reale è il primo anello di una catena di tre passaggi: Speech-to-Text, poi LLM, infine Text-to-Speech. Qui, la latenza scende a 300 millisecondi, il valore più aggressivo dell’intera lezione, e il testo viene visualizzato sovrascrivendo la riga corrente tramite un ritorno a capo, creando l’impressione di una frase che si completa sotto i tuoi occhi.
La seconda metà della funzione passa all’LLM. La risposta viene richiesta anch’essa come stream, così le prime parole arrivano prima che il modello abbia finito la sua frase: la reattività guadagnata nella fase di trascrizione non viene sprecata nel passaggio successivo. Il prompt di sistema impone la concisione, un dettaglio decisivo nell’interazione vocale dove una risposta di dieci righe diventa inascoltabile.
async def assistant_vocal(audio_source):
"""Trascrive e poi risponde tramite un LLM."""
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
# Passaggio 1: Trascrivi la domanda
question_parts = []
async for event in client.audio.realtime.transcribe_stream(
audio_stream=audio_source,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=300,
):
if isinstance(event, TranscriptionStreamTextDelta):
question_parts.append(event.text)
texte_en_cours = "".join(question_parts)
print(f"\rTu: {texte_en_cours}", end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
question = "".join(question_parts).strip()
print()
if not question:
print("Nessuna domanda rilevata.")
return
# Passaggio 2: Invia all'LLM per ottenere una risposta
print("Assistente: ", end="", flush=True)
reponse_stream = client.chat.stream(
model="mistral-large-latest",
messages=[
{
"role": "system",
"content": "Sei un assistente vocale conciso. "
"Rispondi in massimo 2-3 frasi."
},
{"role": "user", "content": question}
]
)
for chunk in reponse_stream:
texte = chunk.data.choices[0].delta.content
if texte:
print(texte, end="", flush=True)
print("\n")
Dettatura vocale con salvataggio automatico
La dettatura pone un problema che i due casi precedenti ignorano: la durata. Una sessione può durare oltre un’ora e perdere il testo a causa di un crash o di un’interruzione sarebbe inaccettabile. Da qui il salvataggio automatico, attivato circa ogni cento parole, che riscrive il file di output al volo. Il contatore nb_mots funge anche da feedback per l’utente: ti dice quanto hai prodotto, un’informazione che chiunque detti un rapporto si aspetta. La latenza di 600 millisecondi posiziona il cursore sul lato della precisione, poiché chi detta rilegge il proprio testo e preferisce una parola accurata a una istantanea.
class DicteeVocale:
"""Dettatura vocale con salvataggio automatico."""
def __init__(self, fichier_sortie="dictee.txt"):
self.fichier_sortie = fichier_sortie
self.texte = []
self.nb_mots = 0
async def run(self, audio_source):
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
print("Dettatura in corso... (Ctrl+C per interrompere)\n")
async for event in client.audio.realtime.transcribe_stream(
audio_stream=audio_source,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=600,
):
if isinstance(event, TranscriptionStreamTextDelta):
self.texte.append(event.text)
self.nb_mots += len(event.text.split())
print(event.text, end="", flush=True)
# Salvataggio automatico ogni 100 parole
if self.nb_mots % 100 < 5:
self._sauvegarder()
elif isinstance(event, TranscriptionStreamDone):
break
self._sauvegarder()
print(f"\n\nDettatura terminata: {self.nb_mots} parole")
print(f"File: {self.fichier_sortie}")
def _sauvegarder(self):
contenu = "".join(self.texte)
with open(self.fichier_sortie, "w", encoding="utf-8") as f:
f.write(contenu)
Trascrizione di conferenze con metadati
Per una lunga conferenza, il testo grezzo non vale molto se non è identificabile. Sei mesi dopo, nessuno saprà da quale sessione o relatore provenga un file chiamato transcription.txt. La funzione seguente avvolge quindi la trascrizione in una struttura documentata (nome della conferenza, relatore, timestamp di inizio e fine, conteggio delle parole) ed esporta il risultato come JSON con un nome basato sul timestamp, immediatamente utilizzabile da un motore di ricerca interno o da una pipeline di archiviazione. La latenza di 1.200 millisecondi è perfettamente adeguata qui: il pubblico ascolta il relatore, il display è solo un supplemento e la precisione ha la priorità.
import json
from datetime import datetime
async def transcribe_conference(
audio_source,
conference_name: str,
speaker: str = "Sconosciuto"
):
"""Trascrive una sessione di conferenza con metadati."""
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
audio_format = AudioFormat(encoding="pcm_s16le", sample_rate=16000)
session = {
"conference": conference_name,
"speaker": speaker,
"debut": datetime.now().isoformat(),
"texte": [],
}
print(f"Trascrizione: {conference_name}")
print(f"Relatore: {speaker}")
print("-" * 50)
async for event in client.audio.realtime.transcribe_stream(
audio_stream=audio_source,
model="voxtral-mini-transcribe-realtime-3",
audio_format=audio_format,
target_streaming_delay_ms=1200,
):
if isinstance(event, TranscriptionStreamTextDelta):
session["texte"].append(event.text)
print(event.text, end="", flush=True)
elif isinstance(event, TranscriptionStreamDone):
break
session["fin"] = datetime.now().isoformat()
session["texte"] = "".join(session["texte"])
session["nb_mots"] = len(session["texte"].split())
filename = f"session_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
with open(filename, "w", encoding="utf-8") as f:
json.dump(session, f, ensure_ascii=False, indent=2)
print(f"\n\nSessione salvata: {filename}")
return session
Rivedi le quattro latenze in ordine: 300, 600, 800 e poi 1.200 millisecondi, e nota che seguono un’unica logica: più l’utente si aspetta una reazione dalla macchina, più breve deve essere il ritardo; più si aspetta un documento utilizzabile, più lungo può essere. Prendi una di queste applicazioni e collegala al generatore di microfono della lezione precedente: avrai uno strumento davvero utilizzabile in pochi minuti.
Punti chiave
- Il sottotitolaggio in diretta utilizza una latenza di 800 ms e gestisce la visualizzazione riga per riga
- L’assistente vocale concatena trascrizione in tempo reale e un LLM per rispondere alle domande
- La dettatura vocale salva automaticamente il testo al volo
- La trascrizione di conferenze aggiunge metadati ed esporta in JSON
- Ogni caso d’uso ha la sua latenza ottimale: da 300 ms (assistente) a 1.200 ms (conferenza), nell’intervallo accettato da 80 a 1.200 ms o 2.400 ms