Ir al contenido principal
Español— Elegir un idioma
Menú

Canalización de voz completa

Lección 14 de 14 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. De la voz a la voz: la canalización STT → LLM → TTS
  2. Una canalización funcional
  3. Deja de esperar a que termine el razonamiento
  4. El bucle conversacional
  5. Qué separa este prototipo de la producción
  6. Próximos pasos
  7. Puntos clave
  8. Pon a prueba tus conocimientos

Curso actualizado el 3 de noviembre de 2026 para Voxtral TTS 3, basado en la guía Migrate from Voxtral 2 y las páginas de Text to Speech de Mistral: voxtral-mini-tts-2603, obsoleto desde el 31 de octubre de 2026 y retirado el 30 de abril de 2027, se sustituye en los ejemplos por voxtral-mini-tts-3-0. Las voces predefinidas de Voxtral 2 (gb_jane_neutral…) siguen siendo compatibles; Voxtral 3 añade las etiquetas [emotion=…] y [pace=…] en el texto, el parámetro expressiveness, la pronunciación personalizada (phoneme_hints) y 35 idiomas. Mistral recomienda volver a medir la latencia tras la migración. Fuentes: Migrate from Voxtral 2 · Speech generation.

Lección corregida el 2 de noviembre de 2026 según la documentación de audio de Mistral: el método de transcripción es client.audio.transcriptions.complete (no create), pasando el archivo como {"file_name": ..., "content": ...}, y el modelo actual es voxtral-mini-transcribe-3. Fuente: Transcribe a file.

De la voz a la voz: la canalización STT → LLM → TTS

Ya sabes crear voces, generar habla y gestionar la latencia. Esta última lección ensambla estos bloques de construcción en un sistema completo: el usuario habla, la máquina escucha, comprende, razona y responde con una voz natural.

La arquitectura consta de tres eslabones. Primero, el reconocimiento de voz convierte el habla en texto; Mistral ofrece su propio modelo, pero Whisper de OpenAI u otra solución funcionan igual de bien. Este texto pasa luego a un modelo de lenguaje grande, que interpreta la solicitud y redacta una respuesta: Mistral Large 3, Claude, GPT-5.6 o Llama; la canalización no asume ningún proveedor concreto. Por último, la respuesta vuelve a Voxtral TTS, que la renderiza como habla y la envía mediante streaming.

Una canalización funcional

El siguiente código encadena los tres pasos. Cada uno está aislado en su propia función, lo que te permite cambiar el modelo STT o LLM sin tocar el resto. Ten en cuenta que el historial de conversación se pasa a generer_reponse() y esta lo enriquece: esto es lo que da coherencia a los intercambios sucesivos.

import base64
from pathlib import Path
from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

# Configuración
VOICE_ID = "your-voice-id"
LLM_MODEL = "mistral-large-latest"
TTS_MODEL = "voxtral-mini-tts-3-0"

def transcribe_audio(audio_path: str) -> str:
    """Paso 1: Convertir audio a texto (STT)."""
    path = Path(audio_path)
    with path.open("rb") as audio:
        response = client.audio.transcriptions.complete(
            model="voxtral-mini-transcribe-3",
            file={"file_name": path.name, "content": audio},
        )
    return response.text

def generate_response(question: str, history: list) -> str:
    """Paso 2: Generar una respuesta con el LLM."""
    history.append({"role": "user", "content": question})

    response = client.chat.complete(
        model=LLM_MODEL,
        messages=history,
    )

    answer = response.choices[0].message.content
    history.append({"role": "assistant", "content": answer})
    return answer

def synthesize_speech(output_file: str, fichier_sortie: str):
    """Paso 3: Convertir texto a habla (TTS)."""
    audio_chunks = []

    with client.audio.speech.complete(
        model=TTS_MODEL,
        input=output_file,
        voice_id=VOICE_ID,
        response_format="pcm",
        stream=True,
    ) as stream:
        for event in stream:
            if event.event == "speech.audio.delta":
                audio_chunks.append(
                    base64.b64decode(event.data.audio_data)
                )

    Path(fichier_sortie).write_bytes(b"".join(audio_chunks))

def pipeline_vocal(audio_path: str):
    """Canalización completa: STT → LLM → TTS."""
    history = [
        {
            "role": "system",
            "content": (
                "Eres un asistente de voz profesional. "
                "Responde de forma concisa y natural, "
                "como en una conversación oral."
            ),
        }
    ]

    # Paso 1: Transcribir
    print("Transcribiendo...")
    question = transcribe_audio(audio_path)
    print(f"Pregunta: {question}")

    # Paso 2: Razonar
    print("Generando respuesta...")
    answer = generate_response(question, history)
    print(f"Respuesta: {answer}")

    # Paso 3: Sintetizar
    print("Sintetizando habla...")
    synthesize_speech(answer, "answer.pcm")
    print("Canalización completada — archivo answer.pcm generado")

# Ejecutar la canalización
pipeline_vocal("question_utilisateur.wav")

El prompt del sistema merece una mención: solicitar explícitamente respuestas concisas y habladas no es un capricho. Un LLM sin restricciones produce de buen grado párrafos estructurados con encabezados, lo cual es desastroso al leerse en voz alta —y además tarda más en sintetizarse.

Deja de esperar a que termine el razonamiento

La canalización anterior es secuencial: la síntesis no comienza hasta que el LLM ha escrito por completo la respuesta. Para una respuesta de treinta palabras, esto añade varios segundos de silencio que el usuario no sabe explicar. La solución es solapar los pasos 2 y 3: el LLM genera en streaming y, en cuanto hay una frase completa —es decir, en cuanto un token termina en punto, signo de exclamación o interrogación—, se envía a síntesis mientras el modelo sigue redactando el resto.

def streaming_pipeline(question_text: str):
    """Canalización optimizada: TTS comienza en cuanto llegan
    los primeros tokens del LLM."""

    # El LLM genera en streaming
    partial_response = ""
    phrases_to_synthesize = []

    llm_stream = client.chat.stream(
        model=LLM_MODEL,
        messages=[
            {"role": "system", "content": "Responde brevemente."},
            {"role": "user", "content": question_text},
        ],
    )

    for chunk in llm_stream:
        token = chunk.data.choices[0].delta.content or ""
        partial_response += token

        # En cuanto hay una frase completa
        if token.endswith((".", "!", "?")):
            phrases_to_synthesize.append(partial_response)
            partial_response = ""

    # Sintetizar cada frase en streaming
    for phrase in phrases_to_synthesize:
        with client.audio.speech.complete(
            model=TTS_MODEL,
            input=phrase,
            voice_id=VOICE_ID,
            response_format="pcm",
            stream=True,
        ) as stream:
            for event in stream:
                if event.event == "speech.audio.delta":
                    yield base64.b64decode(event.data.audio_data)

El bucle conversacional

Un asistente de verdad no gestiona una pregunta aislada: encadena turnos de palabra manteniendo el hilo. El siguiente bucle graba, transcribe, comprueba si el usuario quiere detenerse y luego responde, reinyectando el mismo historique en cada turno, que va creciendo durante el intercambio.

def voice_assistant():
    """Bucle conversacional completo."""
    history = [
        {
            "role": "system",
            "content": "Eres un asistente de voz conciso.",
        }
    ]

    print("Asistente de voz listo. ¡Habla!")

    while True:
        # Grabar la pregunta (vía micrófono)
        audio_question = record_microphone(duration=10)

        # Canalización STT → LLM → TTS
        question = transcribe_audio(audio_question)
        if question.lower() in ("stop", "arrête", "au revoir"):
            synthesize_speech("Goodbye!", "sortie.pcm")
            break

        answer = generate_response(question, history)
        synthesize_speech(answer, "sortie.pcm")
        play_audio("sortie.pcm")

Qué separa este prototipo de la producción

El duree=10 en la grabación ilustra el camino por recorrer: un retraso fijo obliga a un usuario hablador a cortarse y hace que quien responde «sí» espere diez segundos. Un detector de actividad de voz (VAD) soluciona esto detectando realmente el final del habla. Luego hay que gestionar las interrupciones, ya que un usuario cortará de buen grado a un asistente que hable demasiado: tu código debe poder detener una síntesis en curso, algo que el streaming permite pero que este prototipo no hace.

Tres puntos más condicionan el despliegue. El historial de conversación, ya presente aquí, debe tener un límite y persistirse si las sesiones son largas. Un plan de respaldo es esencial: si falla el STT o el TTS, muestra el texto en lugar de dejar un silencio inexplicable. Por último, instrumenta cada paso en producción: es la única forma de saber si ese segundo extra proviene de la transcripción, del LLM o de la síntesis.

Próximos pasos

Ya tienes todo lo necesario para aprovechar Voxtral TTS en tus proyectos. Se abren varias direcciones según tus restricciones: aloja Voxtral localmente si la latencia o el control de datos son primordiales, intégralo en un framework existente como LangChain, LlamaIndex o Haystack, o construye una aplicación web completa con WebRTC para audio bidireccional. También puedes explorar los modelos multimodales de Mistral, que combinan texto, imagen y audio, y unirte a la comunidad de Mistral en Discord para comparar tus construcciones con las de otros.

Puntos clave

  • Un asistente de voz completo encadena tres pasos: STT → LLM → TTS
  • Paralelizar los pasos (generar TTS mientras el LLM continúa) reduce drásticamente la latencia
  • El formato PCM en streaming proporciona la capacidad de respuesta necesaria para una conversación natural
  • En producción, gestiona la detección del final del habla, las interrupciones y el respaldo en texto
  • Voxtral TTS se integra en cualquier canalización de voz gracias al SDK de Python de Mistral

Pon a prueba tus conocimientos

Síntesis, voz, latencia: comprobación final antes de la canalización completa.

1. ¿Qué permite la API de Voices?

Respuesta: Gestionar las voces disponibles y crear otras personalizadas; la voz se convierte en un activo configurado, reutilizable en todas tus generaciones.

2. ¿Qué normas éticas rigen el clonado de voz?

Respuesta: Consentimiento explícito de la persona clonada y un uso transparente y legítimo; clonar una voz sin autorización está fuera de cuestión; que sea técnicamente posible no significa que esté permitido.

3. ¿Cómo controlas la pronunciación del texto?

Respuesta: Preparando el texto: deletrea fonéticamente los términos ambiguos, gestiona acrónimos y números, puntúa para el ritmo; el TTS lee lo que escribes.

4. ¿Qué palancas reducen la latencia?

Respuesta: Streaming en tiempo real (audio producido a medida que llega el texto), formatos de audio adaptados y texto segmentado; la voz comienza antes de que termine la generación.

5. ¿Qué aspecto tiene una canalización de voz completa?

Respuesta: Transcripción del usuario (Voxtral) → procesamiento del modelo → síntesis de la respuesta (TTS), streaming de extremo a extremo: el bucle de un asistente de voz.

El bucle está cerrado: de la voz entrante a la voz saliente; la canalización final del curso ensambla todo lo que acabas de validar.