Un call center produce migliaia di ore di audio al mese, e quasi nessuna viene letta. Le trascrizioni rendono le chiamate ricercabili. I riassunti le rendono verificabili. Questo articolo costruisce la pipeline da capo a fondo, con un’attenzione particolare all’arabo: dialetti, arabo e inglese mescolati e cifre arabo-orientali.
I passaggi:
- Esamina la registrazione: stereo o mono?
- Dividi lo stereo nei canali operatore e cliente.
- Taglia ogni canale in turni di parlato.
- Trascrivi ogni turno con la lingua giusta.
- Unisci i turni in un dialogo per ora di inizio.
- Oscura i dati personali (PII) dal testo.
- Riassumi con un LLM in campi strutturati.
Passo 1: la registrazione è stereo o mono?
ffprobe -v error -show_entries stream=channels,sample_rate,duration -of csv=p=0 call.wav
# 2,8000,412.6 -> stereo, 8 kHz telephone audio, 6.9 minutes
Molti registratori dei contact center salvano l’operatore su un canale e il cliente sull’altro. La guida di AssemblyAI per i contact center dice la stessa cosa: con canali separati ottieni la separazione degli speaker senza diarizzazione. Verifica su qualche chiamata quale lato è quale; l’operatore non è sempre a sinistra.
Passo 2: come si dividono i canali stereo con ffmpeg?
ffmpeg -i call.wav -af "pan=mono|c0=c0" -ar 16000 agent.wav
ffmpeg -i call.wav -af "pan=mono|c0=c1" -ar 16000 customer.wav
Il filtro pan mantiene un solo canale, e -ar 16000 ricampiona a 16 kHz, il formato che la documentazione di BroadNet usa per le registrazioni telefoniche.
Passo 3: come si taglia ogni canale in turni di parlato?
È una forma semplice di rilevamento dell’attività vocale. Inviare ogni canale intero funziona, ma paghi ogni secondo di silenzio mentre parla l’altra persona, il che su una chiamata stereo raddoppia più o meno il conto. Inoltre perdi l’ordine dei turni. Tagliare in corrispondenza dei silenzi risolve entrambe le cose:
import re, subprocess
def speech_turns(wav, noise="-35dB", min_silence=0.6):
"""Return (start, end) seconds of speech, using ffmpeg silencedetect."""
log = subprocess.run(
["ffmpeg", "-i", wav, "-af", f"silencedetect=noise={noise}:d={min_silence}", "-f", "null", "-"],
capture_output=True, text=True).stderr
dur = float(subprocess.run(
["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", wav],
capture_output=True, text=True).stdout)
starts = [float(x) for x in re.findall(r"silence_start: ([\d.]+)", log)]
ends = [float(x) for x in re.findall(r"silence_end: ([\d.]+)", log)]
turns, cursor = [], 0.0
for s, e in zip(starts, ends + [dur]):
if s - cursor > 0.4:
turns.append((cursor, s))
cursor = e
if dur - cursor > 0.4:
turns.append((cursor, dur))
return turns
Regola noise sulle tue registrazioni: le linee rumorose richiedono una soglia più alta, per esempio -30dB.
Passo 4: come si trascrive ogni turno?
import os, tempfile
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
def transcribe_turns(wav, speaker, language="ar"):
out = []
for start, end in speech_turns(wav):
with tempfile.NamedTemporaryFile(suffix=".wav") as seg:
subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-i", wav,
"-ss", f"{start:.2f}", "-to", f"{end:.2f}", seg.name], check=True)
with open(seg.name, "rb") as audio:
text = client.audio.transcriptions.create(
model="broadnet/cohere-transcribe-arabic", file=audio, language=language).text
out.append({"start": start, "speaker": speaker, "text": text.strip()})
return out
Invia sempre language. Senza, l’arabo può tornare in caratteri latini. Per le code in inglese usa broadnet/cohere-transcribe con language="en". Tieni un pool di worker piccolo: le chiavi a consumo consentono 4 richieste in parallelo e 30 al minuto, e la guida a errori e retry mostra come fare backoff sui 429.
I singoli file devono restare sotto i 25 MiB. Un lungo monologo in WAV mono a 16 kHz (circa 32 KB al secondo) supera quel limite intorno ai 13 minuti; dividilo con -f segment -segment_time 600.
Passo 5: come si uniscono i turni in un dialogo?
turns = transcribe_turns("agent.wav", "Agent") + transcribe_turns("customer.wav", "Customer")
dialogue = "\n".join(f'{t["speaker"]}: {t["text"]}' for t in sorted(turns, key=lambda t: t["start"]))
Il parlato sovrapposto compare come due turni con orari di inizio vicini, che è proprio ciò che si aspetta un revisore umano.
E le registrazioni mono?
Senza canali ti serve la diarizzazione degli speaker: stabilire chi ha parlato e quando. Le opzioni:
| Opzione | Come | Compromesso |
|---|---|---|
| Diarizzazione open source | Esegui pyannote.audio sui tuoi server, poi trascrivi ogni segmento di speaker | Ospiti tu un modello; l’audio resta da te |
| Un provider con diarizzazione integrata | Diverse API STT restituiscono le etichette degli speaker; vedi il confronto dei prezzi per i costi aggiuntivi | Un altro fornitore nel percorso dei dati |
| Etichettatura dei ruoli con un LLM | Trascrivi i turni, poi chiedi a un LLM di etichettare ogni turno come operatore o cliente in base al contesto | Economico; sbaglia sui turni brevi o ambigui |
| Risolvere alla fonte | Passa il registratore a doppio canale | La soluzione migliore a lungo termine |
BroadNet non indica la diarizzazione tra le sue funzioni, quindi sull’audio mono abbinalo a una delle prime tre opzioni.
Passo 6: come si oscurano i dati personali, cifre arabe comprese?
Chi chiama legge ad alta voce numeri di carta, IBAN e numeri di telefono. Le trascrizioni possono scriverli in cifre occidentali (0-9) o arabo-orientali (٠-٩). Prima normalizza, poi oscura:
EASTERN = str.maketrans("٠١٢٣٤٥٦٧٨٩۰۱۲۳۴۵۶۷۸۹", "01234567890123456789")
def redact(text):
text = text.translate(EASTERN)
text = re.sub(r"\b(?:\d[ -]?){13,19}\b", "[CARD]", text)
text = re.sub(r"\b[A-Z]{2}\d{2}[A-Z0-9]{11,30}\b", "[IBAN]", text)
text = re.sub(r"\+?\d[\d -]{7,}\d", "[PHONE]", text)
return text
I numeri possono anche essere pronunciati a parole (“خمسة أربعة…”), e le regex non li vedono. Controlla a mano un campione di trascrizioni e aggiungi regole per ciò che trovi. L’approccio più ampio è in inviare dati sensibili a un’API LLM.
Passo 7: come si riassume ogni chiamata con un LLM?
import json
summary = client.chat.completions.create(
model="broadnet/qwen3.8-27b",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Summarise this call centre dialogue. Reply in English JSON with keys: "
"reason, resolution, resolved (true/false), customer_sentiment, follow_up."},
{"role": "user", "content": redact(dialogue)},
],
).choices[0].message.content
print(json.loads(summary))
Qwen3.8 27B supporta l’output strutturato; analizza e valida sempre la risposta (come). Il test di BroadNet ha anche rilevato che capisce i dialetti del Golfo e quello egiziano. Chiedi un JSON in inglese se le tue dashboard sono in inglese, anche quando la chiamata è in arabo.
Quali controlli di qualità vengono prima delle analisi?
Le dashboard costruite su trascrizioni sbagliate sembrano sicure di sé quanto quelle costruite su trascrizioni buone. Aggiungi questi controlli alla pipeline:
- Canali invertiti. Se su qualche registratore o coda le etichette operatore e cliente sono invertite, ogni metrica del tipo «l’operatore ha detto» è sbagliata. Controlla il primo turno: di solito l’operatore apre con un saluto e il nome dell’azienda.
- Trascrizioni vuote o minuscole. Un turno che non restituisce testo, o una chiamata con meno di 20 parole, di solito indica silenzio, musica d’attesa o un file difettoso. Segnalalo invece di riassumerlo.
- Lingua sbagliata. Una coda in inglese che all’improvviso produce testo arabo, o arabo restituito in caratteri latini, indica un valore di
languagesbagliato. - Deriva dei riassunti. Ogni settimana fai confrontare a un supervisore 20 riassunti con la trascrizione completa. Tieni traccia di quanto spesso
resolvedè sbagliato.
Conserva le trascrizioni per turno, non solo il riassunto. Quando un riassunto viene contestato, i turni sono la tua prova.
Quanto costa trascrivere le chiamate?
Con il taglio in turni, l’audio fatturato è vicino al tempo di conversazione. Per 1.000 ore di parlato arabo:
- Trascrizione: $252.00 a $0.0042 al minuto con BroadNet Transcribe Arabic, oppure $120.00 con BroadNet Transcribe a 14 lingue per le code in inglese.
- Riassunti: una chiamata di 7 minuti spesso vale qualche migliaio di token. Calcolane il prezzo nel calcolatore dei costi delle API LLM con le lunghezze reali delle tue trascrizioni, e la parte audio nel calcolatore dei costi dello speech-to-text.
Dove si colloca BroadNet Inference
BroadNet copre i passi 4 e 7 con una sola chiave e un solo base URL: arabo e altre 13 lingue per la trascrizione, e modelli di chat testati sull’arabo per il riassunto. Audio, trascrizioni e prompt non vengono conservati (zero data retention), e BroadNet riporta il suo modello arabo #2 su 37 (dato di settembre 2026; la classifica in tempo reale lo indicava #4 su 39 il 15 novembre 2026) sull’Open Universal Arabic ASR Leaderboard.
Non si occupa per te di diarizzazione, trascrizione in tempo reale né oscuramento; restano nella tua pipeline. Prima di impegnarti, prova i tuoi dialetti con il metodo descritto in riconoscimento vocale dei dialetti arabi.

