Mesurer et analyser la latence

Pourquoi la latence est votre métrique numéro un

Lorsque vous déployez une application alimentée par un LLM en production, la latence perçue par vos utilisateurs détermine directement l’adoption. Une réponse qui met 8 secondes à apparaître fait fuir 70 % des utilisateurs. Cette leçon vous apprend à mesurer, décomposer et diagnostiquer la latence de bout en bout.

Les composantes de la latence

La latence totale d’un appel API se décompose en plusieurs segments :

• Latence réseau : temps de transit entre votre serveur et l’API OpenAI
• Time to First Token (TTFT) : temps avant que le premier token ne soit généré
• Time Per Output Token (TPOT) : vitesse de génération de chaque token suivant
• Latence applicative : traitement côté serveur avant et après l’appel API

Mesurer avec Python

Voici comment instrumenter un appel à la Responses API pour capturer chaque segment :

import time
import openai

client = openai.OpenAI()

def mesurer_latence(prompt: str, model: str = "gpt-5.3") -> dict:
    """Mesure la latence décomposée d'un appel API."""
    metriques = {}

    debut_total = time.perf_counter()

    # Appel en streaming pour mesurer le TTFT
    stream = client.responses.create(
        model=model,
        input=prompt,
        stream=True,
    )

    premier_token = True
    tokens_sortie = 0

    for event in stream:
        if event.type == "response.output_text.delta":
            if premier_token:
                metriques["ttft"] = time.perf_counter() - debut_total
                debut_generation = time.perf_counter()
                premier_token = False
            tokens_sortie += 1

    metriques["duree_totale"] = time.perf_counter() - debut_total
    metriques["tokens_sortie"] = tokens_sortie
    if tokens_sortie > 1:
        metriques["tpot"] = (
            (metriques["duree_totale"] - metriques["ttft"]) / (tokens_sortie - 1)
        )

    return metriques

resultat = mesurer_latence("Expliquez le théorème de Bayes en 3 phrases.")
for cle, valeur in resultat.items():
    print(f"{cle}: {valeur:.4f}" if isinstance(valeur, float) else f"{cle}: {valeur}")

Diagnostiquer les goulots d’étranglement

TTFT élevé

Un TTFT élevé (> 2 secondes) indique généralement :

• Un prompt système trop long non mis en cache
• L’utilisation d’un modèle de raisonnement (o3-pro, o4-mini) qui réfléchit avant de répondre
• Un pic de charge côté OpenAI

TPOT élevé

Un TPOT élevé (> 50 ms/token) peut venir de :

• Un max_output_tokens très élevé qui force des séquences longues
• L’utilisation de function calling complexe avec de nombreux outils

Outils de monitoring

Pour un suivi continu en production, intégrez ces métriques dans votre stack d’observabilité :

import logging
from dataclasses import dataclass, field

@dataclass
class MetriquesLatence:
    """Agrège les métriques de latence sur une fenêtre glissante."""
    mesures: list[dict] = field(default_factory=list)

    def ajouter(self, mesure: dict) -> None:
        self.mesures.append(mesure)
        if len(self.mesures) > 1000:
            self.mesures = self.mesures[-1000:]

    @property
    def ttft_p50(self) -> float:
        valeurs = sorted(m["ttft"] for m in self.mesures if "ttft" in m)
        if not valeurs:
            return 0.0
        return valeurs[len(valeurs) // 2]

    @property
    def ttft_p99(self) -> float:
        valeurs = sorted(m["ttft"] for m in self.mesures if "ttft" in m)
        if not valeurs:
            return 0.0
        idx = int(len(valeurs) * 0.99)
        return valeurs[min(idx, len(valeurs) - 1)]

    def rapport(self) -> str:
        return (
            f"TTFT p50={self.ttft_p50:.3f}s p99={self.ttft_p99:.3f}s | "
            f"Échantillons: {len(self.mesures)}"
        )

Points clés à retenir

• La latence se décompose en TTFT + génération (TPOT x tokens) + réseau
• Mesurez toujours en streaming pour obtenir le TTFT réel
• Suivez les percentiles p50 et p99, pas seulement la moyenne
• Le choix du modèle impacte directement la latence : GPT-5.3 est plus rapide que o3-pro