Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Komplet tale-pipeline

Lektion 14 af 14 Opdateret 3. november 2026 Udvikler
På denne side
  1. Fra tale til tale: STT → LLM → TTS-pipelinen
  2. En funktionel pipeline
  3. Stop med at vente på, at ræsonnementet bliver færdigt
  4. Den konversationelle løkke
  5. Hvad der adskiller denne prototype fra produktion
  6. Næste skridt
  7. Vigtige pointer
  8. Test din viden

Kurset opdateret 3. november 2026 til Voxtral TTS 3, baseret på guiden Migrate from Voxtral 2 og Mistrals sider om Text to Speech: voxtral-mini-tts-2603, der blev udfaset 31. oktober 2026 og trukket tilbage 30. april 2027, erstattes i eksemplerne af voxtral-mini-tts-3-0. Voxtral 2’s foruddefinerede stemmer (gb_jane_neutral…) understøttes fortsat; Voxtral 3 tilføjer [emotion=…]- og [pace=…]-tags i teksten, indstillingen expressiveness, brugerdefineret udtale (phoneme_hints) og 35 sprog. Mistral anbefaler at genmåle ventetiden efter migrationen. Kilder: Migrate from Voxtral 2 · Speech generation.

Lektionen korrigeret 2. november 2026 baseret på Mistrals lyd-dokumentation: transkriptionsmetoden er client.audio.transcriptions.complete (ikke create), hvor filen sendes som {"file_name": ..., "content": ...}, og den aktuelle model er voxtral-mini-transcribe-3. Kilde: Transcribe a file.

Fra tale til tale: STT → LLM → TTS-pipelinen

Du ved allerede, hvordan du opretter stemmer, genererer tale og håndterer ventetid. Denne sidste lektion samler disse byggesten til et komplet system: Brugeren taler, maskinen lytter, forstår, ræsonnerer og svarer med en naturlig stemme.

Arkitekturen består af tre led. Først omdanner talegenkendelse tale til tekst; Mistral tilbyder sin egen model, men OpenAI’s Whisper eller en anden løsning fungerer lige så godt. Denne tekst sendes derefter til en stor sprogmodel (LLM), som fortolker forespørgslen og udarbejder et svar – det kan være Mistral Large 3, Claude, GPT-5.6 eller Llama; pipelinen gør ingen antagelser om udbyderen. Til sidst returneres svaret til Voxtral TTS, som gengiver det som tale og sender det via streaming.

En funktionel pipeline

Koden nedenfor kæder de tre trin sammen. Hvert trin er isoleret i sin egen funktion, så du kan udskifte STT- eller LLM-modellen uden at røre ved resten. Bemærk, at samtalehistorikken sendes til og beriges af generer_reponse(): Det er dette, der giver sammenhæng i successive udvekslinger.

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

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

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

def transcribe_audio(audio_path: str) -> str:
    """Trin 1: Konverter lyd til tekst (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:
    """Trin 2: Generer et svar med LLM'en."""
    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):
    """Trin 3: Konverter tekst til tale (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):
    """Komplet pipeline: STT → LLM → TTS."""
    history = [
        {
            "role": "system",
            "content": (
                "You are a professional voice assistant. "
                "Respond concisely and naturally, "
                "as in an oral conversation."
            ),
        }
    ]

    # Trin 1: Transkriber
    print("Transkriberer...")
    question = transcribe_audio(audio_path)
    print(f"Spørgsmål: {question}")

    # Trin 2: Ræsonner
    print("Genererer svar...")
    answer = generate_response(question, history)
    print(f"Svar: {answer}")

    # Trin 3: Syntetiser
    print("Syntetiserer tale...")
    synthesize_speech(answer, "answer.pcm")
    print("Pipeline fuldført — filen answer.pcm er genereret")

# Kør pipelinen
pipeline_vocal("question_utilisateur.wav")

System-prompten fortjener et ord: At eksplicit anmode om koncise, talte svar er ikke bare en høflighed. En ubegrænset LLM producerer gerne strukturerede afsnit med overskrifter, hvilket er katastrofalt, når det læses højt – og tager endnu længere tid at syntetisere.

Stop med at vente på, at ræsonnementet bliver færdigt

Den tidligere pipeline er sekventiel: Syntesen starter først, når LLM’en har skrevet hele svaret færdigt. Ved et svar på tredive ord tilføjer dette flere sekunders stilhed, som brugeren ikke kan forklare. Løsningen er at overlappe trin 2 og 3: LLM’en genererer via streaming, og så snart en komplet sætning er tilgængelig – dvs. så snart et token slutter med et punktum, udråbstegn eller spørgsmålstegn – sendes den til syntese, mens modellen fortsætter med at udkaste resten.

def streaming_pipeline(question_text: str):
    """Optimeret pipeline: TTS starter, så snart de første
    LLM-tokens ankommer."""

    # LLM genererer via 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

        # Så snart en komplet sætning er tilgængelig
        if token.endswith((".", "!", "?")):
            phrases_to_synthesize.append(partial_response)
            partial_response = ""

    # Syntetiser hver sætning via 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)

Den konversationelle løkke

En ægte assistent håndterer ikke et isoleret spørgsmål: Den kæder taleturer sammen, mens tråden holdes. Løkken nedenfor optager, transkriberer, tjekker om brugeren vil stoppe, og svarer derefter – den genindsætter den samme historique ved hver tur, hvilket får den til at vokse gennem hele udvekslingen.

def voice_assistant():
    """Komplet konversationel løkke."""
    history = [
        {
            "role": "system",
            "content": "You are a concise voice assistant.",
        }
    ]

    print("Taleassistent klar. Tal!")

    while True:
        # Optag spørgsmålet (via mikrofon)
        audio_question = record_microphone(duration=10)

        # STT → LLM → TTS pipeline
        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")

Hvad der adskiller denne prototype fra produktion

duree=10 i optagelsen illustrerer vejen frem: En fast forsinkelse tvinger en snakkesalig bruger til at afbryde sig selv og får nogen, der svarer “ja”, til at vente ti sekunder. En detector for taleaktivitet (VAD) løser dette ved faktisk at registrere talestop. Derefter skal du håndtere afbrydelser, da en bruger gerne afbryder en assistent, der taler for længe: Din kode skal kunne stoppe en igangværende syntese, hvilket streaming muliggør, men denne prototype gør det ikke.

Tre andre punkter er afgørende for implementering. Samtalehistorikken, som allerede er til stede her, skal begrænses og persistere, hvis sessioner varer længe. En fallback-løsning er essentiel – hvis STT eller TTS fejler, skal teksten vises i stedet for at efterlade uforklarlig stilhed. Endelig skal du instrumentere hvert trin i produktion: Det er den eneste måde at vide, om det ekstra sekund kommer fra transkriptionen, LLM’en eller syntesen.

Næste skridt

Du har nu alt, hvad du behøver for at udnytte Voxtral TTS i dine projekter. Flere retninger åbner sig afhængigt af dine begrænsninger: Host Voxtral lokalt, hvis ventetid eller datakontrol er altafgørende, integrer det i et eksisterende framework som LangChain, LlamaIndex eller Haystack, eller byg en komplet webapplikation med WebRTC til tovejs lyd. Du kan også udforske Mistrals multimodale modeller, som kombinerer tekst, billede og lyd, og joining Mistral-fællesskabet på Discord for at sammenligne dine builds med andre.

Vigtige pointer

  • En komplet taleassistent kæder tre trin sammen: STT → LLM → TTS
  • Parallelisering af trin (generering af TTS mens LLM’en fortsætter) reducerer ventetiden drastisk
  • PCM-format i streaming giver den responsivitet, der kræves for naturlig samtale
  • I produktion skal du håndtere detektering af talestop, afbrydelser og tekst-fallback
  • Voxtral TTS integreres i enhver tale-pipeline takket være Mistral Python SDK

Test din viden

Syntese, stemme, ventetid: Finalt tjek før den komplette pipeline.

1. Hvad tillader Voices API'en?

Svar: Administrere tilgængelige stemmer og oprette brugerdefinerede – stemmen bliver en konfigureret aktiv, der kan genbruges på tværs af alle dine generationer.

2. Hvilke etiske regler gælder for stemmekloning?

Svar: Eksplicit samtykke fra den person, der klones, og transparent, legitim brug – kloning af en stemme uden tilladelse er udelukket; at noget er teknisk muligt betyder ikke, at det er tilladt.

3. Hvordan styrer du udtalen af tekst?

Svar: Ved at forberede teksten: Stav fonetisk tvetydige begreber, håndter akronymer og tal, sæt tegnsætning for rytme – TTS’en læser det, du skriver.

4. Hvilke løftestænger reducerer ventetiden?

Svar: Real-tids streaming (lyd produceres, mens tekst ankommer), tilpassede lydformater og segmenteret tekst – stemmen starter før generationen slutter.

5. Hvordan ser en komplet tale-pipeline ud?

Svar: Brugerkonvertering (Voxtral) → modelbehandling → svar-syntese (TTS), streaming ende-til-ende: løkken for en taleassistent.

Løkken er sluttet: Fra indgående tale til udgående tale – kursets sidste pipeline samler alt, hvad du lige har valideret.