Prompt Caching LLM : cache KV 10 fois moins cher

# Mise en cache des prompts dans les LLM : Optimisation du cache KV pour réduire les coûts et la latence

La mise en cache des prompts réduit les coûts des tokens d'entrée des LLM par un facteur de 10 et diminue la latence jusqu'à 85 % pour les prompts longs. OpenAI et Anthropic ne mettent pas en cache les réponses ; ils mettent en cache les calculs intermédiaires dans le mécanisme d'attention du transformer — plus précisément le cache KV. Cela stocke les paires clé-valeur pour les préfixes de prompts répétés, accélérant l'inférence sans sacrifier la qualité de génération.

Cette technologie est idéale pour les tâches avec un contexte répété : RAG, chatbots avec historique de conversation, pipelines multi-étapes. Des tests sur les fournisseurs d'API montrent que l'utilisation complète du cache procure un gain de vitesse significatif pour le premier token.

Architecture des LLM et rôle de l'attention

Un LLM est une séquence de blocs transformer, chacun prenant des embeddings en entrée et produisant des représentations mises à jour. L'inférence s'exécute en boucle : le prompt est tokenisé, les embeddings passent par les couches d'attention et feed-forward, le token suivant est généré, et il est ajouté au contexte.

prompt = "What is the meaning of life?";
tokens = tokenizer(prompt);
while (true) {
    embeddings = embed(tokens);
    for ([attention, feedforward] of transformers) {
        embeddings = attention(embeddings);
        embeddings = feedforward(embeddings);
    }
    output_token = output(embeddings);
    if (output_token === END_TOKEN) {
        break;
    }
    tokens.push(output_token);
}
print(decode(tokens));

Le cache se produit dans l'attention. L'auto-attention calcule une somme pondérée des tokens précédents pour chaque token en fonction de la similarité entre la requête (token courant) et les clés (tokens précédents). Pour query_i : attention(Q_i, K, V) = softmax(Q_i K^T / sqrt(d)) V.

Lors de la génération de chaque nouveau token, le cache KV pour tous les tokens précédents s'étend, menant à une complexité quadratique O(n^2) par rapport à la longueur de la séquence.

Tokenisation et embeddings

Le tokenizer décompose le texte en unités subword et assigne des ID. Exemple pour GPT : "Check out ngrok.ai" → [4383, 842, 1657, 17690, 75584]. Il est déterministe, sensible à la casse, et utilise des algorithmes de type BPE.

Les embeddings transforment les tokens en vecteurs n-dimensionnels (n > 10k dans les grands modèles). La matrice d'embeddings est fixe après l'entraînement :

function embed(tokens) {
    return tokens.map((token, i) => {
        const embeddings = EMBEDDINGS[token];
        return encodePosition(embeddings, i);
    });
}

L'encodage positionnel ajoute des informations sur l'ordre. Plus de dimensions capturent mieux les sémantiques : ton, style, similarité.

Mécanisme d'attention et cache KV

Dans l'attention multi-tête :

• Projections : Q = X W_Q, K = X W_K, V = X * W_V (X — matrice d'embeddings).
• Scores : attention_scores = Q * K^T / sqrt(d_k).
• Softmax et somme pondérée : attention_output = softmax(scores) * V.

Pour une séquence de longueur n, le cache KV consiste en tenseurs K et V de taille [n, d_model]. Lors de la génération du t-ième token, l'attention utilise l'ensemble du cache passé plus le courant.

La mise en cache des prompts sauvegarde le cache KV du préfixe de prompt à travers les appels API. Si un nouveau prompt commence par un préfixe mis en cache (hit), les calculs d'attention pour ces tokens sont sautés — le KV prêt est utilisé à la place. Les coûts chutent car ~90 % des calculs sont sautés pour les contextes longs.

• Cache hit : préfixe > 1024 tokens (Anthropic), coût /10.
• Cache miss : recalcul complet.
• TTL : cache vit ~5-10 min, dépend du fournisseur.

Avantages et limitations

Gains de latence : pour les prompts avec 10k+ tokens, TTFB chute de 50-85 %.

Économies : tokens d'entrée mis en cache — $0.0001/1k vs $0.001/1k (approx).

Limitations :

• Correspondance préfixe uniquement (pas de sous-chaînes arbitraires).
• Ne met pas en cache les embeddings de sortie ou logits.
• Dépend du tokenizer du fournisseur.

En production : utiliser pour les chats basés sur session où l'historique se répète.

Points clés

• La mise en cache des prompts met en cache les paires KV d'attention pour les préfixes, réduisant les calculs de 90 %+ pour les contextes longs.
• Temps jusqu'au premier token chute jusqu'à 85 %, coûts d'entrée /10.
• Nécessite une correspondance exacte de préfixe et tokenizer compatible.
• Parfait pour RAG, historiques de chat, tâches multi-itérations.
• Aucun impact sur la qualité : la génération reste stochastique.

— Editorial Team