> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gradium.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Des tokens LLM au TTS en streaming

> Envoyez du texte généré en flux vers le TTS tout en préservant la prosodie et une faible latence

Utilisez ce modèle lorsqu'un LLM produit du texte de manière incrémentale et que
vous voulez que l'utilisateur entende l'audio avant que la réponse complète soit
terminée.

Le principe :

1. Ouvrez un WebSocket TTS avant que le LLM ne démarre.
2. Regroupez les tokens du LLM en fragments de mots ou de phrases.
3. Envoyez chaque fragment comme message `text`.
4. Ajoutez `<flush>` lorsque le LLM termine une phrase ou la réponse entière.
5. Lisez les messages `audio` en parallèle et diffusez-les vers la lecture.

## Envoyer les tokens LLM en streaming vers le TTS

```python theme={null}
import asyncio
import gradium


async def play_pcm(chunk: bytes):
    # Replace with your audio playback sink.
    ...


async def phrase_chunks(llm_tokens):
    buffer = []
    async for token in llm_tokens:
        buffer.append(token)
        text = "".join(buffer)
        if text.endswith((".", "?", "!", ", ")) or len(text) > 80:
            yield text
            buffer = []
    if buffer:
        yield "".join(buffer) + " <flush>"


async def speak_llm(llm_tokens):
    client = gradium.client.GradiumClient(api_key="your-api-key")

    async with client.tts_realtime(
        voice_id="YTpq7expH9539ERJ",
        output_format="pcm",
    ) as tts:
        async def sender():
            async for chunk in phrase_chunks(llm_tokens):
                await tts.send_text(chunk)
            await tts.send_eos()

        async def receiver():
            async for msg in tts:
                if msg["type"] == "audio":
                    await play_pcm(msg["audio"])
                elif msg["type"] == "end_of_stream":
                    return

        await asyncio.gather(sender(), receiver())
```

## Règles de découpage

* Envoyez des mots, des groupes de mots ou des phrases complets.
* Gardez la ponctuation attachée au mot qui la précède.
* Évitez d'envoyer un token par message, sauf si les tokens correspondent déjà à
  des mots complets.
* Ajoutez `<flush>` aux limites naturelles, en particulier lorsque le LLM a
  terminé sa réponse.
* Évitez les flush fréquents : ils réduisent le contexte du modèle et peuvent
  rendre la prosodie saccadée.

## Gérer les interruptions

Si l'utilisateur interrompt l'agent :

1. Arrêtez d'envoyer du texte.
2. Arrêtez la lecture localement.
3. Fermez le WebSocket en cours.
4. Ouvrez un nouveau WebSocket pour la réponse suivante.

Pour plusieurs réponses indépendantes sur une même connexion, utilisez le
[multiplexage](/fr/guides/multiplexing) et routez l'audio selon le
`client_req_id`.

## Voir aussi

<CardGroup cols={2}>
  <Card title="WebSocket de synthèse vocale" icon="waveform-lines" href="/fr/guides/text-to-speech">
    Le guide complet du streaming TTS.
  </Card>

  <Card title="Cycle de vie WebSocket" icon="diagram-project" href="/fr/guides/websocket-lifecycle">
    Setup, ready, entrée, flush, fin et erreurs.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.