> ## 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.

# Gestion des tours de parole avec la VAD sémantique

> Utilisez la VAD sémantique et le délai adaptatif de la transcription (STT) pour déterminer quand un utilisateur a fini de parler

La transcription (STT) de Gradium émet des messages `step` toutes les 80 ms. Chaque `step` contient
des prédictions de VAD sémantique : la probabilité que le locuteur soit
inactif à plusieurs horizons futurs. Combinez ces probabilités
avec `delay_in_frames` et `flush` pour construire une gestion des tours de parole
réactive, qui ne coupe pas la parole aux gens.

Utilisez ces signaux pour décider quand un agent doit répondre.

## Règle de base

Commencez par l'horizon le plus long et un seuil d'environ `0.5` :

```python theme={null}
def turn_has_probably_ended(msg):
    if msg["type"] != "step" or not msg["vad"]:
        return False
    horizon = msg["vad"][-1]
    return horizon["inactivity_prob"] > 0.5
```

Il s'agit d'un point de départ, pas d'une règle universelle. Ajustez selon l'application :

| Ressenti recherché | Réglage suggéré |
| - | - |
| Assistant rapide | Horizon plus court ou seuil plus bas. |
| Assistant prudent | Horizon plus long ou seuil plus élevé. |
| Téléphonie bruyante | Exigez plusieurs `step` consécutifs à confiance élevée. |
| Dictée | Privilégiez des contrôles explicites par l'utilisateur ou un silence plus long. |

## Boucle complète

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


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

    async with client.stt_realtime(
        model_name="default",
        input_format="pcm",
        json_config={"language": "en", "delay_in_frames": 16},
    ) as stt:
        transcript = []
        high_vad_steps = 0

        async def producer():
            async for chunk in audio_source:
                await stt.send_audio(chunk)
            await stt.send_eos()

        async def consumer():
            nonlocal high_vad_steps, transcript

            async for msg in stt:
                if msg["type"] == "text":
                    transcript.append(msg["text"])

                elif msg["type"] == "step":
                    inactivity = msg["vad"][-1]["inactivity_prob"]
                    high_vad_steps = high_vad_steps + 1 if inactivity > 0.5 else 0

                    if high_vad_steps >= 3 and transcript:
                        await stt.send_flush(flush_id=1)

                elif msg["type"] == "flushed":
                    text = " ".join(transcript).strip()
                    transcript = []
                    high_vad_steps = 0
                    await handle_user_turn(text)

                elif msg["type"] == "end_of_stream":
                    return

        await asyncio.gather(producer(), consumer())
```

## Délai adaptatif

`delay_in_frames` contrôle la quantité de contexte qu'utilise le modèle de transcription avant
d'émettre du texte. Chaque trame dure 80 ms. Des valeurs plus élevées peuvent améliorer la qualité
du texte mais retardent la sortie. Des valeurs plus faibles sont plus réactives mais peuvent être
moins stables. Les valeurs prises en charge sont `7`, `8`, `10`, `12`, `14`, `16`,
`20`, `24`, `32`, `36` et `48`.

Lorsque l'application estime qu'un tour est terminé, `send_flush()` demande au serveur
de traiter l'audio en attente, puis renvoie un message `flushed`
correspondant. Considérez `flushed` comme le moment où le tour en cours est prêt
pour l'étape suivante du pipeline de votre agent.

## Voir aussi

<CardGroup cols={2}>
  <Card title="WebSocket de transcription (STT)" icon="microphone" href="/fr/guides/speech-to-text">
    Types de messages STT, détails de la VAD et flush.
  </Card>

  <Card title="Paramètres de transcription" icon="sliders" href="/fr/guides/transcription-settings">
    Réglez `language`, `temp`, `padding_bonus` et `delay_in_frames`.
  </Card>
</CardGroup>


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