Un call center produce miles de horas de audio al mes, y casi nada de eso se lee. Las transcripciones hacen que las llamadas se puedan buscar. Los resúmenes hacen que se puedan revisar. Este artículo construye el pipeline de principio a fin, con un enfoque árabe: dialectos, mezcla de árabe e inglés y dígitos arábigo-orientales.
Los pasos:
- Inspeccione la grabación: ¿estéreo o mono?
- Separe el estéreo en los canales del agente y del cliente.
- Corte cada canal en turnos de habla.
- Transcriba cada turno con el idioma correcto.
- Una los turnos en un diálogo por hora de inicio.
- Oculte los datos personales (PII) del texto.
- Resuma con un LLM en campos estructurados.
Paso 1: ¿la grabación es estéreo 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
Muchos sistemas de grabación de contact center guardan al agente en un canal y al cliente en el otro. La guía de AssemblyAI para contact centers señala lo mismo: con canales separados, obtiene la separación de hablantes sin diarización. Compruebe en algunas llamadas qué lado es cuál; el izquierdo no siempre es el del agente.
Paso 2: ¿cómo separar los canales estéreo 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
El filtro pan conserva un canal y -ar 16000 remuestrea a 16 kHz, el formato que usa la documentación de BroadNet para grabaciones telefónicas.
Paso 3: ¿cómo cortar cada canal en turnos de habla?
Esta es una forma sencilla de detección de actividad de voz. Enviar cada canal completo funciona, pero paga por cada segundo de silencio mientras habla la otra parte, lo que en una llamada estéreo prácticamente duplica la factura. Además pierde el orden de los turnos. Cortar en los silencios resuelve ambas cosas:
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
Ajuste noise con sus propias grabaciones: las líneas con ruido necesitan un umbral más alto, como -30dB.
Paso 4: ¿cómo transcribir cada 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
Envíe siempre language. Sin él, el árabe puede volver en letras latinas. Para colas en inglés, use broadnet/cohere-transcribe con language="en". Mantenga un grupo pequeño de workers: las claves de pago por uso permiten 4 solicitudes simultáneas y 30 por minuto, y la guía de errores y reintentos muestra cómo aplicar backoff ante un 429.
Cada archivo debe quedar por debajo de 25 MiB. Un monólogo largo en WAV mono a 16 kHz (unos 32 KB por segundo) supera ese tamaño hacia los 13 minutos; divídalo con -f segment -segment_time 600.
Paso 5: ¿cómo unir los turnos en un diálogo?
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"]))
El habla superpuesta aparece como dos turnos con horas de inicio cercanas, que es lo que espera un revisor humano.
¿Y las grabaciones mono?
Sin canales necesita diarización de hablantes: decidir quién habló y cuándo. Opciones:
| Opción | Cómo | Contrapartida |
|---|---|---|
| Diarización de código abierto | Ejecute pyannote.audio en sus servidores y luego transcriba cada segmento de hablante | Usted aloja un modelo; el audio se queda con usted |
| Un proveedor con diarización integrada | Varias API de voz a texto devuelven etiquetas de hablante; consulte la comparación de precios para el costo de los complementos | Un proveedor más en la ruta de los datos |
| Etiquetado de roles con un LLM | Transcriba los turnos y pida a un LLM que etiquete cada turno como Agent o Customer según el contexto | Barato; se equivoca en turnos cortos o ambiguos |
| Resolverlo en el origen | Cambie el sistema de grabación a doble canal | La mejor solución a largo plazo |
BroadNet no ofrece diarización, así que con audio mono combínelo con una de las tres primeras opciones.
Paso 6: ¿cómo ocultar los datos personales, incluidos los dígitos árabes?
Quienes llaman dictan en voz alta números de tarjeta, IBAN y teléfonos. Las transcripciones pueden escribirlos con dígitos occidentales (0-9) o arábigo-orientales (٠-٩). Normalice primero y luego oculte:
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
Los números también pueden decirse con palabras (“خمسة أربعة…”), que las expresiones regulares no detectan. Revise a mano una muestra de transcripciones y añada reglas para lo que encuentre. El enfoque general está en enviar datos sensibles a una API de LLM.
Paso 7: ¿cómo resumir cada llamada 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 admite salida estructurada; analice y valide siempre la respuesta (cómo hacerlo). La propia prueba de BroadNet encontró además que entiende los dialectos del Golfo y egipcio. Pida JSON en inglés si sus dashboards están en inglés, aunque la llamada sea en árabe.
¿Qué controles de calidad van antes de la analítica?
Los dashboards construidos sobre malas transcripciones se ven tan seguros como los construidos sobre buenas. Añada estos controles al pipeline:
- Canales intercambiados. Si las etiquetas de agente y cliente están invertidas en algún grabador o cola, toda métrica del tipo «el agente dijo» es incorrecta. Revise el primer turno: los agentes suelen abrir con un saludo y el nombre de la empresa.
- Transcripciones vacías o mínimas. Un turno que no devuelve texto, o una llamada con menos de 20 palabras, suele indicar silencio, música de espera o un archivo defectuoso. Márquelo en lugar de resumirlo.
- Idioma que no corresponde. Una cola en inglés que de pronto produce texto en árabe, o árabe devuelto en letras latinas, apunta a un valor de
languageincorrecto. - Deriva de los resúmenes. Cada semana, pida a un supervisor que compare 20 resúmenes con la transcripción completa. Lleve la cuenta de cuántas veces
resolvedes incorrecto.
Guarde las transcripciones de cada turno, no solo el resumen. Cuando se cuestione un resumen, los turnos son su evidencia.
¿Cuánto cuesta transcribir llamadas?
Con el corte por turnos, el audio facturado se acerca al tiempo de conversación. Para 1,000 horas de habla en árabe:
- Transcripción: $252.00 a $0.0042 por minuto con BroadNet Transcribe Arabic, o $120.00 con BroadNet Transcribe de 14 idiomas para colas en inglés.
- Resúmenes: una llamada de 7 minutos suele ser de unos pocos miles de tokens. Calcule su costo en la calculadora de costos de API de LLM con la longitud real de sus transcripciones, y la parte de audio en la calculadora de costos de voz a texto.
Dónde encaja BroadNet Inference
BroadNet cubre los pasos 4 y 7 con una sola clave y una sola base URL: árabe y otros 13 idiomas para la transcripción, y modelos de chat probados en árabe para el resumen. El audio, las transcripciones y los prompts no se retienen (retención de datos cero), y BroadNet informa que su modelo árabe ocupa #2 de 37 (su cifra de septiembre de 2026; el tablero en vivo lo situaba en el #4 de 39 el 15 de noviembre de 2026) en el Open Universal Arabic ASR Leaderboard.
No hace por usted la diarización, la transcripción en tiempo real ni la ocultación de datos; eso queda en su pipeline. Antes de comprometerse, pruebe sus dialectos con el método de reconocimiento de voz en dialectos árabes.

