« L’API est lente » peut vouloir dire trois choses différentes, et chacune a sa solution. Un utilisateur de chat attend le premier mot. Un agent attend l’appel d’outil complet. Un traitement par lots se soucie des tokens par heure. Cet article définit les trois chiffres, montre comment les mesurer depuis votre propre code, et associe chaque correctif au chiffre qu’il fait réellement bouger.
Que sont le TTFT, les tokens par seconde et la latence de bout en bout ?
Le guide de benchmark de NVIDIA donne des définitions nettes, qui correspondent à ce que vous pouvez observer côté client :
| Métrique | Ce qu’elle mesure | Qui la ressent | Dépend de |
|---|---|---|---|
| Time to first token (TTFT) | Requête envoyée → premier token reçu | Utilisateurs de chat | Réseau, file d’attente, longueur du prompt (prefill), hits de cache |
| Latence inter-tokens (ITL) | Écart moyen entre deux tokens | Lecteurs d’une réponse en streaming | Taille du modèle, matériel, charge du serveur |
| Tokens par seconde par utilisateur | Tokens de sortie après le premier ÷ temps de génération (du premier au dernier token) ; égal à 1 ÷ ITL moyenne | Lecteurs, agents | Comme l’ITL |
| Latence de bout en bout | Requête envoyée → dernier token reçu | Agents, API, traitements par lots | TTFT + temps de génération |
La formule qui les relie :
bout en bout ≈ TTFT + (tokens de sortie − 1) × ITL ≈ TTFT + tokens de sortie ÷ tokens par seconde par utilisateur
La vitesse par utilisateur n’est pas le débit du serveur, c’est-à-dire le total des tokens qu’il produit pour tous les utilisateurs ; un fournisseur peut augmenter l’un pendant que l’autre baisse.
Prenons la vitesse typique que BroadNet publie pour son modèle de forfait, environ 100 tokens par seconde. Le temps de génération croît avec la longueur de la réponse : un fichier de code de 4 000 tokens prend environ quatre-vingts fois plus de temps à générer qu’une classification de 50 tokens, alors que les deux attendent le même TTFT. Pour les réponses courtes, le TTFT représente l’essentiel de l’attente ; pour les longues, ce sont la vitesse et la longueur.
Pourquoi les modèles de raisonnement ont-ils besoin d’un quatrième chiffre ?
Les modèles de raisonnement comme DeepSeek V4.1 Flash réfléchissent avant de répondre, et cette réflexion est elle aussi faite de tokens de sortie. Si le modèle consacre 800 tokens au raisonnement à environ 100 tokens par seconde, l’utilisateur attend que les 800 soient générés avant de voir le premier mot, même si le TTFT mesuré sur le réseau paraît rapide. Mesurez donc séparément le temps jusqu’au premier token de contenu. Sur BroadNet Inference, reasoning_effort: "low" raccourcit la réflexion pour les étapes simples ; le guide du raisonnement explique le compromis.
Comment mesurer la latence côté client ?
Chronométrez là où se trouvent vos utilisateurs, avec le streaming activé. Les chronomètres côté serveur ignorent le réseau et tout proxy.
import os, time, statistics
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
def timed(model, messages, max_tokens=1500):
t0 = time.perf_counter()
first = first_content = None
usage = None
stream = client.chat.completions.create(
model=model, messages=messages, max_tokens=max_tokens,
stream=True, stream_options={"include_usage": True},
)
for chunk in stream:
now = time.perf_counter()
if chunk.choices:
if first is None:
first = now
if chunk.choices[0].delta.content and first_content is None:
first_content = now
if chunk.usage:
usage = chunk.usage
end = time.perf_counter()
out = usage.completion_tokens if usage else 0
return {
"ttft": first - t0,
"ttfct": (first_content or end) - t0,
"e2e": end - t0,
"tps": (out - 1) / (end - first) if out > 1 and end > first else 0,
"prompt_tokens": usage.prompt_tokens if usage else None,
}
runs = [timed("broadnet/gemma-4-26b-a4b", [{"role": "user", "content": "Summarise SSE in 100 words."}]) for _ in range(50)]
for k in ("ttft", "ttfct", "e2e", "tps"):
xs = sorted(r[k] for r in runs)
print(k, "p50", round(statistics.median(xs), 3), "p95", round(xs[int(len(xs) * 0.95) - 1], 3))
Cinq règles pour un benchmark équitable :
- Fixez la longueur du prompt et indiquez-la. Le TTFT à 500 tokens de prompt et à 200 000 sont deux chiffres différents. Le compteur de tokens vous donne la longueur d’un prompt de test avant de l’envoyer.
- Fixez la longueur de sortie avec
max_tokenset un prompt qui la remplit, pour que les tokens par seconde soient comparables. - Indiquez le p50 et le p95, pas la moyenne. C’est la latence de traîne dont les utilisateurs se souviennent.
- Étalez les exécutions dans le temps. La charge varie au cours de la journée.
- Faites d’abord un échauffement. Le premier appel paie le DNS, le TLS et l’établissement de la connexion ; réutilisez un même client.
Qu’est-ce qui améliore réellement chaque chiffre ?
| Pour améliorer | Faites ceci | Pourquoi |
|---|---|---|
| TTFT | Raccourcir ou mettre en cache le préfixe du prompt | Le temps de prefill croît avec la longueur du prompt ; les préfixes en cache évitent du travail |
| TTFT | Garder les connexions chaudes, utiliser une région proche | Supprime l’établissement de connexion et des allers-retours |
| Temps jusqu’au premier token de contenu | Baisser l’effort de raisonnement, ou utiliser un modèle sans raisonnement pour les étapes simples | Moins de réflexion cachée avant la réponse |
| Tokens par seconde | Utiliser un modèle plus petit ou plus rapide pour l’étape | La vitesse de décodage dépend de la taille du modèle et du service |
| Bout en bout | Demander une sortie plus courte (schémas, limites de mots) | La longueur de sortie multiplie l’ITL |
| Bout en bout sur de nombreux appels | Exécuter en parallèle les appels indépendants dans la limite de votre simultanéité | Le temps total baisse même si chaque appel reste identique |
| Latence perçue | Diffuser en streaming vers l’utilisateur | Il lit pendant que le modèle écrit |
La longueur de sortie est le levier le plus sous-estimé. Demander « du JSON avec ces quatre champs » au lieu de « explique ta réponse » peut réduire le temps de génération d’un ordre de grandeur, sans aucun travail d’infrastructure. La sortie structurée y aide.
Le levier du cache est traité dans structurer ses prompts pour le cache. Le levier du parallélisme se heurte vite aux limites de débit ; voir gérer les erreurs 429.
Comment la longueur du prompt change-t-elle le compromis ?
Le TTFT croît avec le prompt, car le modèle doit traiter chaque token d’entrée avant de pouvoir écrire. C’est le coût caché des prompts très longs, et une partie de l’arbitrage contexte long ou RAG : un prompt de 1 M de tokens répond à des questions que le RAG ne peut pas traiter, mais il démarre plus lentement. Si la vitesse interactive compte, gardez le chemin critique court et n’envoyez le gros contexte que lorsque la question l’exige.
Où se situe BroadNet Inference
BroadNet publie une vitesse typique de environ 100 tokens par seconde pour son modèle de forfait et diffuse au format SSE standard : le code ci-dessus fonctionne donc tel quel. Il ne publie ni chiffres de TTFT ni SLA de latence ; mesurez donc sur vos propres prompts avant de vous engager. Une heure Meteor à $1 suffit pour un benchmark de 50 exécutions, et le crédit de départ en couvre un sur Gemma 4 VL 26B. S’il vous faut une latence garantie sous la seconde à grande échelle, testez soigneusement : une clé à l’usage autorise 4 requêtes en cours, ce qui convient mieux aux applications et aux agents qu’à un service temps réel à fort volume. Les modèles et leurs prix sont sur les pages modèles et tarifs.
