Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Casi d'uso della trascrizione in tempo reale

Lezione 13 di 16 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Quattro applicazioni di streaming concrete
  2. Sottotitolaggio in diretta
  3. Assistente vocale interattivo
  4. Dettatura vocale con salvataggio automatico
  5. Trascrizione di conferenze con metadati
  6. Punti chiave

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 da voxtral-mini-transcribe-3, voxtral-mini-transcribe-realtime-3 e voxtral-mini-tts-3-0. Cambiamenti chiave: i timestamp sono solo per segmento (word restituisce 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 input context_bias sono 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