Stratégies de mise en cache pour les agents IA : réduire les coûts sans compromis

Votre agent de recherche exécute 50 tâches par jour. Chaque tâche commence avec le même prompt système de 3 000 tokens, les mêmes définitions d’outils de 2 500 tokens et la même base de connaissances de 5 000 tokens. Cela représente 10 500 tokens répétés 50 fois — 525 000 tokens par jour que le modèle lit de façon identique à chaque fois. Avec la tarification standard, vous payez pour traiter le même contenu encore et encore.

La mise en cache est l’optimisation la moins coûteuse en effort et la plus impactante pour les agents en production. Le cache de prompts seul peut réduire les coûts des tokens d’entrée de 90 % pour le contenu mis en cache. Combiné au cache des résultats d’outils, vous pouvez souvent réduire de moitié le coût total de l’agent — sans sacrifier la qualité, la précision ou la flexibilité.

Dans cet article, vous apprendrez trois couches de mise en cache pour les agents — le cache de prompts, le cache des résultats d’outils et la mémoïsation des réponses — avec des modèles d’implémentation utilisant l’API de Claude et une analyse de coûts claire pour guider vos décisions.

Section 1 : Anatomie des coûts d’un agent

Avant d’optimiser, vous devez comprendre où vont réellement vos tokens. Décomposons un workflow agentique typique.

Répartition des tokens par tour

Dans une architecture d’agent standard, chaque appel API au modèle inclut :

La surcharge statique — prompt système, définitions d’outils et base de connaissances — totalise environ 6 500 tokens par tour, et elle est identique à chaque fois.

Le problème des coûts composés

Les agents ne font pas un seul appel API. Ils bouclent. Une exécution typique d’un agent en 15 étapes ressemble à ceci :

Sans mise en cache :

Chacune des 15 étapes envoie le contexte complet. En supposant que l’historique de conversation croît d’environ ~300 tokens par étape en moyenne :

• Tokens statiques par étape : 6 500
• Total des tokens statiques sur 15 étapes : 97 500
• Tokens d’historique de conversation (cumulatifs) : ~33 750
• Tokens de résultats d’outils : ~7 500
• Total des tokens d’entrée : ~138 750

Avec la tarification d’entrée de Claude Sonnet à 3 $ par million de tokens, cela représente environ 0,42 $ par tâche. Exécutez 50 tâches par jour et vous regardez 21 $/jour — rien que sur les tokens d’entrée.

Avec le cache de prompts :

Les tokens mis en cache sont facturés à 0,30 $ par million pour les lectures de cache (réduction de 90 %). Si vous mettez en cache les 6 500 tokens statiques :

• Lectures de tokens en cache sur 15 étapes : 97 500 tokens × 0,30 $/M = 0,029 $
• Les tokens non mis en cache restent à la tarification standard : ~41 250 × 3 $/M = 0,124 $
• Écriture du cache (première étape) : 6 500 × 3,75 $/M = 0,024 $
• Coût total d’entrée : ~0,18 $ par tâche

C’est une réduction de 57 % grâce à la mise en cache seule. À 50 tâches par jour, vous économisez plus de 12 $/jour — environ 360 $/mois — avec des modifications de code minimales.

Section 2 : Cache de prompts avec Claude

L’API de cache de prompts de Claude est l’optimisation la plus impactante que vous puissiez appliquer aux workflows agentiques. Elle vous permet de dire à l’API « cette partie de mon prompt n’a pas changé — réutilisez le calcul mis en cache. »

Fonctionnement du cache de prompts

Lorsque vous envoyez une requête avec la mise en cache activée, l’infrastructure d’Anthropic :

1. Vérifie si une version en cache du préfixe marqué existe
2. En cas de cache manqué : Traite le prompt complet, met le préfixe en cache, et facture des frais d’écriture de cache (prime de 25 % par rapport à la tarification standard des tokens d’entrée)
3. En cas de cache atteint : Réutilise le calcul mis en cache, en facturant uniquement les frais de lecture de cache (réduction de 90 % par rapport à la tarification standard des tokens d’entrée)

Le cache a un TTL de 5 minutes (Time to Live — la durée avant l’expiration des données mises en cache). Chaque accès au cache réinitialise le TTL, donc les agents actifs maintiennent naturellement leur cache actif. Les traitements par lots avec des intervalles de plus de 5 minutes entre les appels entraîneront des coûts d’écriture de cache plus fréquents.

Quoi mettre en cache

Tout ne peut pas ou ne doit pas être mis en cache. Mettez en cache les préfixes stables et répétés :

• Prompts système — Presque toujours identiques d’une exécution à l’autre. Mettez-les en cache en premier.
• Définitions d’outils — Vos schémas d’outils changent rarement entre les appels.
• Bases de connaissances statiques — Documents de référence, directives, politiques.
• Préfixes de conversation — Pour les conversations multi-tours, mettez en cache les tours précédents qui ne changeront pas.

Contraintes importantes :

• La mise en cache est basée sur les préfixes — vous pouvez uniquement mettre en cache le contenu depuis le début du prompt, dans l’ordre. Vous ne pouvez pas mettre en cache une section au milieu en laissant les sections précédentes non mises en cache.
• Il y a une longueur minimale pouvant être mise en cache de 1 024 tokens pour Claude Sonnet et Haiku (2 048 pour Opus).
• Vous pouvez définir jusqu’à 4 points d’arrêt de cache dans une seule requête.

Implémentation

Voici un exemple complet montrant la configuration d’un agent avec le cache de prompts :

Avant (sans mise en cache) :

import anthropic

client = anthropic.Anthropic()

SYSTEM_PROMPT = """You are a research assistant specializing in market analysis.
You have access to tools for searching databases, reading files, and performing
calculations. Always cite your sources and provide confidence levels for your
findings. [... detailed instructions totaling ~1,500 tokens ...]"""

TOOLS = [
    {
        "name": "search_database",
        "description": "Search the company database for market data, competitor info, or financial records.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search query"},
                "database": {"type": "string", "enum": ["market", "competitors", "financial"]},
                "limit": {"type": "integer", "description": "Max results", "default": 10}
            },
            "required": ["query", "database"]
        }
    },
    {
        "name": "read_file",
        "description": "Read the contents of a research file.",
        "input_schema": {
            "type": "object",
            "properties": {
                "file_path": {"type": "string", "description": "Path to the file"}
            },
            "required": ["file_path"]
        }
    },
    # ... more tools totaling ~2,000 tokens in definitions
]

KNOWLEDGE_BASE = """## Company Policies and Guidelines
[... reference material totaling ~3,000 tokens ...]"""

def run_agent(user_query: str):
    messages = [{"role": "user", "content": user_query}]

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        system=f"{SYSTEM_PROMPT}\n\n{KNOWLEDGE_BASE}",
        tools=TOOLS,
        messages=messages,
    )
    # Log token usage
    print(f"Input tokens: {response.usage.input_tokens}")
    return response

Après (avec cache de prompts) :

import anthropic

client = anthropic.Anthropic()

SYSTEM_PROMPT = """You are a research assistant specializing in market analysis.
You have access to tools for searching databases, reading files, and performing
calculations. Always cite your sources and provide confidence levels for your
findings. [... detailed instructions totaling ~1,500 tokens ...]"""

KNOWLEDGE_BASE = """## Company Policies and Guidelines
[... reference material totaling ~3,000 tokens ...]"""

TOOLS = [
    {
        "name": "search_database",
        "description": "Search the company database for market data, competitor info, or financial records.",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Search query"},
                "database": {"type": "string", "enum": ["market", "competitors", "financial"]},
                "limit": {"type": "integer", "description": "Max results", "default": 10}
            },
            "required": ["query", "database"]
        }
    },
    {
        "name": "read_file",
        "description": "Read the contents of a research file.",
        "input_schema": {
            "type": "object",
            "properties": {
                "file_path": {"type": "string", "description": "Path to the file"}
            },
            "required": ["file_path"]
        },
        "cache_control": {"type": "ephemeral"}  # Cache breakpoint after tools
    },
]

def run_agent_cached(user_query: str):
    messages = [{"role": "user", "content": user_query}]

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        system=[
            {
                "type": "text",
                "text": SYSTEM_PROMPT,
            },
            {
                "type": "text",
                "text": KNOWLEDGE_BASE,
                "cache_control": {"type": "ephemeral"},  # Cache breakpoint
            },
        ],
        tools=TOOLS,
        messages=messages,
    )
    # Log token usage — now includes cache metrics
    usage = response.usage
    print(f"Input tokens: {usage.input_tokens}")
    print(f"Cache read tokens: {usage.cache_read_input_tokens}")
    print(f"Cache creation tokens: {usage.cache_creation_input_tokens}")
    return response

Les changements clés :

1. Le paramètre system devient

Articles Connexes

• Optimisation des coûts des agents : guide pratique pour réduire les dépenses API
• Récupération d’Erreurs pour Agents : 5 Patrons pour la Fiabilité en Production
• Patterns d’Utilisation des Outils : Interfaces Agent-Outil Fiables