Un centre d’appels produit des milliers d’heures d’audio par mois, et presque rien n’en est jamais lu. Les transcriptions rendent les appels consultables. Les résumés permettent de les passer en revue. Cet article construit le pipeline de bout en bout, sous un angle arabe : dialectes, arabe et anglais mêlés, et chiffres arabes orientaux.
Les étapes :
- Examiner l’enregistrement : stéréo ou mono ?
- Séparer la stéréo en canal agent et canal client.
- Découper chaque canal en tours de parole.
- Transcrire chaque tour avec la bonne langue.
- Fusionner les tours en dialogue par heure de début.
- Masquer les PII dans le texte.
- Résumer avec un LLM en champs structurés.
Étape 1 : l’enregistrement est-il en stéréo ou en 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
Beaucoup d’enregistreurs de centres de contact stockent l’agent sur un canal et le client sur l’autre. Le guide d’AssemblyAI pour les centres de contact fait la même remarque : avec des canaux séparés, vous obtenez la séparation des locuteurs sans diarisation. Vérifiez sur quelques appels quel côté correspond à qui ; l’agent n’est pas toujours à gauche.
Étape 2 : comment séparer les canaux stéréo avec 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
Le filtre pan conserve un seul canal, et -ar 16000 rééchantillonne en 16 kHz, le format qu’utilise la documentation de BroadNet pour les enregistrements téléphoniques.
Étape 3 : comment découper chaque canal en tours de parole ?
C’est une forme simple de détection d’activité vocale. Envoyer chaque canal en entier fonctionne, mais vous payez chaque seconde de silence pendant que l’autre partie parle, ce qui double à peu près la facture d’un appel stéréo. Vous perdez aussi l’ordre des tours. Découper aux silences règle les deux problèmes :
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
Réglez noise sur vos propres enregistrements : les lignes bruyantes demandent un seuil plus élevé, comme -30dB.
Étape 4 : comment transcrire chaque tour ?
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
Envoyez toujours language. Sans lui, l’arabe peut revenir en lettres latines. Pour les files en anglais, utilisez broadnet/cohere-transcribe avec language="en". Gardez un petit pool de workers : les clés en paiement à l’usage autorisent 4 requêtes simultanées et 30 par minute, et le guide des erreurs et nouvelles tentatives montre comment temporiser sur un 429.
Chaque fichier doit rester sous 25 Mio. Un long monologue en WAV mono 16 kHz (environ 32 Ko par seconde) dépasse cette limite vers 13 minutes ; découpez-le avec -f segment -segment_time 600.
Étape 5 : comment fusionner les tours en dialogue ?
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"]))
Les paroles qui se chevauchent apparaissent comme deux tours aux heures de début proches, ce qu’attend un relecteur humain.
Et les enregistrements mono ?
Sans canaux, il vous faut une diarisation des locuteurs : déterminer qui a parlé quand. Les options :
| Option | Comment | Compromis |
|---|---|---|
| Diarisation open source | Exécuter pyannote.audio sur vos serveurs, puis transcrire chaque segment de locuteur | Vous hébergez un modèle ; l’audio reste chez vous |
| Un fournisseur avec diarisation intégrée | Plusieurs API STT renvoient des étiquettes de locuteur ; voir la comparaison des prix pour le coût des options | Un fournisseur de plus sur le chemin des données |
| Étiquetage des rôles par LLM | Transcrire les tours, puis demander à un LLM d’étiqueter chaque tour Agent ou Client d’après le contexte | Peu coûteux ; se trompe sur les tours courts ou ambigus |
| Corriger à la source | Passer l’enregistreur en double canal | La meilleure solution à long terme |
BroadNet ne propose pas de diarisation : sur de l’audio mono, associez-le donc à l’une des trois premières options.
Étape 6 : comment masquer les PII, chiffres arabes compris ?
Les appelants lisent à voix haute des numéros de carte, des IBAN et des numéros de téléphone. Les transcriptions peuvent les écrire en chiffres occidentaux (0-9) ou en chiffres arabes orientaux (٠-٩). Normalisez d’abord, puis masquez :
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
Les nombres peuvent aussi être prononcés en toutes lettres (« خمسة أربعة… »), ce qu’une regex ne verra pas. Relisez à la main un échantillon de transcriptions et ajoutez des règles pour ce que vous trouvez. L’approche générale est décrite dans envoyer des données sensibles à une API LLM.
Étape 7 : comment résumer chaque appel avec 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 prend en charge la sortie structurée ; analysez et validez toujours la réponse (comment faire). Le test de BroadNet a aussi montré qu’il comprend les dialectes du Golfe et égyptien. Demandez du JSON en anglais si vos tableaux de bord sont en anglais, même quand l’appel est en arabe.
Quels contrôles qualité placer avant l’analytique ?
Des tableaux de bord construits sur de mauvaises transcriptions ont l’air aussi sûrs d’eux que ceux construits sur de bonnes. Ajoutez ces contrôles au pipeline :
- Canaux inversés. Si les étiquettes agent et client sont inversées sur un enregistreur ou une file, toutes les métriques « l’agent a dit » sont fausses. Vérifiez le premier tour : les agents ouvrent généralement par une salutation et un nom d’entreprise.
- Transcriptions vides ou minuscules. Un tour qui ne renvoie aucun texte, ou un appel de moins de 20 mots, signifie généralement du silence, une musique d’attente ou un fichier défectueux. Signalez-le au lieu de le résumer.
- Langue incohérente. Une file anglaise qui produit soudain du texte arabe, ou de l’arabe renvoyé en lettres latines, indique une mauvaise valeur de
language. - Dérive des résumés. Chaque semaine, demandez à un superviseur de comparer 20 résumés avec la transcription complète. Suivez la fréquence à laquelle
resolvedest faux.
Conservez les transcriptions par tour, pas seulement le résumé. Quand un résumé est contesté, les tours sont votre preuve.
Combien coûte la transcription d’appels ?
Avec le découpage en tours, la durée facturée est proche du temps de parole. Pour 1 000 heures de parole arabe :
- Transcription : $252.00 à $0.0042 la minute avec BroadNet Transcribe Arabic, ou $120.00 avec BroadNet Transcribe, qui couvre 14 langues, pour les files en anglais.
- Résumés : un appel de 7 minutes représente souvent quelques milliers de tokens. Chiffrez-le dans le calculateur de coût d’API LLM avec vos vraies longueurs de transcription, et la partie audio dans le calculateur de coût speech-to-text.
Où se situe BroadNet Inference
BroadNet couvre les étapes 4 et 7 avec une seule clé et une seule URL de base : l’arabe et 13 autres langues pour la transcription, et des modèles de chat testés en arabe pour le résumé. L’audio, les transcriptions et les prompts ne sont pas conservés (conservation zéro des données), et BroadNet indique #2 sur 37 (chiffre de septembre 2026 ; le classement en direct le plaçait #4 sur 39 le 15 novembre 2026) pour son modèle arabe sur l’Open Universal Arabic ASR Leaderboard.
Il ne fait pour vous ni la diarisation, ni la transcription en temps réel, ni le masquage : ces étapes restent dans votre pipeline. Avant de vous engager, testez vos dialectes avec la méthode de la reconnaissance vocale des dialectes arabes.

