BroadRouter

Latence LLM : TTFT, tokens par seconde et temps de bout en bout

Par l’équipe BroadNet Inference · 4 min de lecture · Publié · Mis à jour

Le time to first token (TTFT) est l’attente avant le premier token de sortie. Les tokens par seconde mesurent la vitesse de diffusion. La latence de bout en bout est le total : TTFT plus temps de génération (≈ sortie ÷ vitesse). Le prompt et la file d’attente pèsent sur le TTFT, le modèle et la charge sur la vitesse, la longueur de réponse sur le total. Mesurez les trois au p50 et au p95.

« 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 :

  1. 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.
  2. Fixez la longueur de sortie avec max_tokens et un prompt qui la remplit, pour que les tokens par seconde soient comparables.
  3. Indiquez le p50 et le p95, pas la moyenne. C’est la latence de traîne dont les utilisateurs se souviennent.
  4. Étalez les exécutions dans le temps. La charge varie au cours de la journée.
  5. 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.

Questions fréquentes

Quel est un bon time to first token pour une API LLM ?

Pour du chat, moins d’une seconde environ sur des prompts courts donne une impression de réactivité. Les prompts longs et les modèles de raisonnement prennent plus de temps par nature. Ne comparez le TTFT qu’à longueur de prompt et modèle identiques.

Les tokens par seconde, est-ce la même chose que le débit ?

Pas tout à fait. Les tokens par seconde par utilisateur indiquent à quelle vitesse une réponse est diffusée. Le débit est le total des tokens qu’un serveur produit pour l’ensemble des utilisateurs. Un fournisseur peut augmenter le débit total pendant que la vitesse de chaque utilisateur baisse.

Pourquoi le TTFT est-il si élevé sur un modèle de raisonnement ?

Le modèle génère des tokens de raisonnement cachés avant la réponse visible. Le premier token peut arriver vite, mais le premier token de contenu attend la fin de la réflexion. Baissez reasoning_effort pour les tâches simples.

Le streaming réduit-il la latence ?

Il ne raccourcit pas le temps de bout en bout. Il permet à l’utilisateur de lire la réponse pendant qu’elle s’écrit : la latence perçue tombe donc à peu près au TTFT.

Combien de requêtes faut-il pour un benchmark de latence fiable ?

Assez pour voir la traîne. Cinquante à cent requêtes par taille de prompt donnent un p95 exploitable. Répartissez-les sur la journée, car la charge varie.

Lire en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity