Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Pipeline vocal complet

Paskaita 14 iš 14 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. De la voix à la voix : le pipeline STT → LLM → TTS
  2. Un pipeline fonctionnel
  3. Ne plus attendre la fin du raisonnement
  4. La boucle conversationnelle
  5. Ce qui sépare ce prototype de la production
  6. Prochaines étapes
  7. Svarbiausi punktai
  8. Teste tes connaissances

Cours mis à jour le 3 novembre 2026 pour Voxtral TTS 3, sur la base du guide Migrate from Voxtral 2 et des pages Text to Speech de Mistral : voxtral-mini-tts-2603, déprécié le 31 octobre 2026 et retiré le 30 avril 2027, est remplacé dans les exemples par voxtral-mini-tts-3-0. Les voix prédéfinies de Voxtral 2 (gb_jane_neutral…) restent prises en charge ; Voxtral 3 ajoute les balises [emotion=…] et [pace=…] dans le texte, le paramètre expressiveness, la prononciation personnalisée (phoneme_hints) et 35 langues. Mistral recommande de remesurer la latence après la migration. Sources : Migrate from Voxtral 2 · Speech generation.

Leçon corrigée le 2 novembre 2026 selon la documentation audio de Mistral : la méthode de transcription est client.audio.transcriptions.complete (et non create), avec le fichier passé sous la forme {"file_name": ..., "content": ...}, et le modèle actuel est voxtral-mini-transcribe-3. Source : Transcribe a file.

De la voix à la voix : le pipeline STT → LLM → TTS

Tu sais maintenant créer des voix, générer de la parole et gérer la latence. Cette dernière leçon assemble ces briques en un système complet : l’utilisateur parle, la machine écoute, comprend, raisonne et répond d’une voix naturelle.

L’architecture comporte trois maillons. D’abord, la reconnaissance vocale convertit la parole en texte ; Mistral propose son propre modèle, mais Whisper d’OpenAI ou une autre solution fonctionne tout aussi bien. Ce texte passe ensuite à un grand modèle de langage, qui interprète la demande et rédige une réponse — Mistral Large 3, Claude, GPT-5.6 ou Llama ; le pipeline ne fait aucune hypothèse sur le fournisseur. Enfin, la réponse revient vers Voxtral TTS, qui la rend sous forme audio envoyée en streaming.

Un pipeline fonctionnel

Le code ci-dessous enchaîne les trois étapes. Chacune est isolée dans sa propre fonction, ce qui te permet de changer le modèle STT ou LLM sans toucher au reste. Note que l’historique de conversation est transmis à generer_reponse() et enrichi par celle-ci : c’est ce qui assure la cohérence des échanges successifs.

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

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

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

def transcribe_audio(audio_path: str) -> str:
    """Étape 1 : Convertir l'audio en texte (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:
    """Étape 2 : Générer une réponse avec le 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):
    """Étape 3 : Convertir le texte en parole (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):
    """Pipeline complet : STT → LLM → TTS."""
    history = [
        {
            "role": "system",
            "content": (
                "You are a professional voice assistant. "
                "Respond concisely and naturally, "
                "as in an oral conversation."
            ),
        }
    ]

    # Étape 1 : Transcription
    print("Transcription en cours...")
    question = transcribe_audio(audio_path)
    print(f"Question : {question}")

    # Étape 2 : Raisonnement
    print("Génération de la réponse...")
    answer = generate_response(question, history)
    print(f"Réponse : {answer}")

    # Étape 3 : Synthèse
    print("Synthèse vocale en cours...")
    synthesize_speech(answer, "answer.pcm")
    print("Pipeline terminé — fichier answer.pcm généré")

# Exécuter le pipeline
pipeline_vocal("question_utilisateur.wav")

Le prompt système mérite une précision : demander explicitement des réponses concises et parlées n’est pas une simple politesse. Un LLM non contraint produit volontiers des paragraphes structurés avec des titres, ce qui est désastreux à l’oral — et prend encore plus de temps à synthétiser.

Ne plus attendre la fin du raisonnement

Le pipeline précédent est séquentiel : la synthèse ne démarre qu’une fois que le LLM a entièrement rédigé la réponse. Pour une réponse de trente mots, cela ajoute plusieurs secondes de silence que l’utilisateur ne peut expliquer. La solution consiste à chevaucher les étapes 2 et 3 : le LLM génère en streaming, et dès qu’une phrase complète est disponible — c’est-à-dire dès qu’un jeton se termine par un point, un point d’exclamation ou d’interrogation — elle part en synthèse pendant que le modèle continue de rédiger la suite.

def streaming_pipeline(question_text: str):
    """Pipeline optimisé : le TTS démarre dès l'arrivée
    des premiers jetons du LLM."""

    # Le LLM génère en streaming
    partial_response = ""
    phrases_to_synthesize = []

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

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

        # Dès qu'une phrase complète est disponible
        if token.endswith((".", "!", "?")):
            phrases_to_synthesize.append(partial_response)
            partial_response = ""

    # Synthétiser chaque phrase 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)

La boucle conversationnelle

Un véritable assistant ne traite pas une question isolée : il enchaîne les tours de parole tout en gardant le fil. La boucle ci-dessous enregistre, transcrit, vérifie si l’utilisateur souhaite s’arrêter, puis répond — en réinjectant le même historique à chaque tour, qui grossit au fil de l’échange.

def voice_assistant():
    """Boucle conversationnelle complète."""
    history = [
        {
            "role": "system",
            "content": "You are a concise voice assistant.",
        }
    ]

    print("Assistant vocal prêt. Parlez !")

    while True:
        # Enregistrer la question (via le micro)
        audio_question = record_microphone(duration=10)

        # Pipeline 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")

Ce qui sépare ce prototype de la production

Le duree=10 dans l’enregistrement illustre le chemin restant : un délai fixe oblige un utilisateur bavard à se couper et fait attendre dix secondes quelqu’un qui répond „oui“. Un détecteur d’activité vocale (VAD) résout ce problème en détectant réellement la fin de la parole. Il faut ensuite gérer les interruptions, car un utilisateur coupera volontiers un assistant qui parle trop longtemps : ton code doit pouvoir arrêter une synthèse en cours, ce que le streaming rend possible mais que ce prototype ne fait pas.

Trois autres points conditionnent le déploiement. L’historique de conversation, déjà présent ici, doit être borné et persisté si les sessions durent. Un repli est essentiel — si le STT ou le TTS échoue, affiche le texte plutôt que de laisser un silence inexpliqué. Enfin, instrumente chaque étape en production : c’est le seul moyen de savoir si cette seconde supplémentaire vient de la transcription, du LLM ou de la synthèse.

Prochaines étapes

Tu as maintenant tout ce qu’il faut pour exploiter Voxtral TTS dans tes projets. Plusieurs directions s’ouvrent selon tes contraintes : héberger Voxtral en local si la latence ou le contrôle des données est primordial, l’intégrer dans un framework existant comme LangChain, LlamaIndex ou Haystack, ou construire une application web complète avec WebRTC pour l’audio bidirectionnel. Tu peux aussi explorer les modèles multimodaux de Mistral, qui combinent texte, image et audio, et rejoindre la communauté Mistral sur Discord pour comparer tes réalisations avec celles des autres.

Svarbiausi punktai

  • Un assistant vocal complet enchaîne trois étapes : STT → LLM → TTS
  • Paralléliser les étapes (générer le TTS pendant que le LLM continue) réduit drastiquement la latence
  • Le format PCM en streaming offre la réactivité nécessaire à une conversation naturelle
  • En production, gère la détection de fin de parole, les interruptions et le repli texte
  • Voxtral TTS s’intègre dans n’importe quel pipeline vocal grâce au SDK Python de Mistral

Teste tes connaissances

Synthèse, voix, latence : dernière vérification avant le pipeline complet.

1. Que permet l'API Voices ?

Réponse : Gérer les voix disponibles et en créer de personnalisées — la voix devient un actif configuré, réutilisable dans toutes tes générations.

2. Quelles règles éthiques régissent le clonage vocal ?

Réponse : Consentement explicite de la personne clonée et usage transparent et légitime — cloner une voix sans autorisation est hors de question ; techniquement possible ne signifie pas permis.

3. Comment contrôler la prononciation du texte ?

Réponse : En préparant le texte : épeler phonétiquement les termes ambigus, gérer les acronymes et les nombres, ponctuer pour le rythme — le TTS lit ce que tu écris.

4. Quels leviers réduisent la latence ?

Réponse : Le streaming temps réel (audio produit au fur et à mesure que le texte arrive), des formats audio adaptés et un texte segmenté — la voix démarre avant la fin de la génération.

5. À quoi ressemble un pipeline vocal complet ?

Réponse : Transcription utilisateur (Voxtral) → traitement par le modèle → synthèse de la réponse (TTS), en streaming de bout en bout : la boucle d’un assistant vocal.

La boucle est bouclée : de la voix entrante à la voix sortante — le pipeline final du cours assemble tout ce que tu viens de valider.