Mise en cache des invites avec des agents profonds

Mise en cache des prompts avec les agents profonds

Introduction

Les grands modèles de langage (LLM) sont devenus des outils indispensables pour les développeurs et les entreprises, mais leur coût et leur latence restent des obstacles majeurs à un déploiement à grande échelle. L'une des solutions les plus prometteuses à ces défis est la **mise en cache des prompts** — une technique qui stocke et réutilise les segments de prompts déjà traités pour éviter des calculs redondants. Combinée aux architectures d'agents profonds, où plusieurs étapes de raisonnement ou appels d'outils sont exécutés séquentiellement, la mise en cache des prompts peut réduire considérablement à la fois les temps de réponse et les coûts d'API.

Cet article fournit un guide technique et pratique pour implémenter la mise en cache des prompts avec des agents profonds. Nous aborderons l'installation, la configuration et des exemples d'utilisation concrets, en nous appuyant sur les connaissances d'acteurs majeurs comme LangChain, OpenAI, Microsoft et Anthropic.

Qu'est-ce que la mise en cache des prompts ?

La mise en cache des prompts fonctionne en stockant le cache clé-valeur (KV) des prompts précédemment traités. Lorsqu'un nouveau prompt partage un préfixe avec un prompt mis en cache, le système réutilise le calcul mis en cache au lieu de retraiter l'intégralité de l'entrée. Cette technique est particulièrement utile pour :

• Les prompts système longs qui restent constants entre plusieurs requêtes
• Les exemples few-shot réutilisés pour des tâches similaires
• Les boucles d'agents profonds où le même contexte est passé à plusieurs appels d'outils

Les agents profonds — systèmes autonomes qui raisonnent, planifient et exécutent plusieurs étapes — bénéficient de manière disproportionnée de la mise en cache car ils traitent à plusieurs reprises le même contexte de base (instructions système, historique de conversation, définitions d'outils) tout en générant différentes séquences d'actions.

Prérequis

Avant d'implémenter la mise en cache des prompts avec des agents profonds, assurez-vous de disposer des éléments suivants :

• **Python 3.10 ou version ultérieure** (3.11+ recommandé pour les performances)
• **LangChain** (version 0.3 ou ultérieure) pour l'orchestration des agents
• **Un fournisseur de LLM prenant en charge la mise en cache des prompts** (par exemple, OpenAI, Anthropic ou Microsoft Azure OpenAI)
• **Un framework d'agent profond** (LangGraph ou AgentExecutor de LangChain)
• **Au moins 8 Go de RAM** (16 Go+ recommandé pour les modèles plus volumineux)

Installation pas à pas

1. Créer un environnement virtuel

Isolez vos dépendances pour éviter les conflits :

python -m venv prompt-cache-env
source prompt-cache-env/bin/activate  # Sur Windows : prompt-cache-env\Scripts\activate

2. Installer les dépendances principales

Installez LangChain et le framework d'agent :

pip install langchain langchain-openai langchain-anthropic langgraph

Pour les utilisateurs de Microsoft Azure OpenAI, installez l'intégration Azure :

pip install langchain-azure-openai

3. Configurer les clés API

Définissez vos clés API comme variables d'environnement. Cela permet de sécuriser les identifiants et de les garder hors de votre code :

export OPENAI_API_KEY="votre-clé-api-openai-ici"
export ANTHROPIC_API_KEY="votre-clé-api-anthropic-ici"
export AZURE_OPENAI_API_KEY="votre-clé-api-azure-ici"
export AZURE_OPENAI_ENDPOINT="https://votre-ressource.openai.azure.com/"

Sous Windows, utilisez `set` au lieu de `export` :

set OPENAI_API_KEY="votre-clé-api-openai-ici"

4. Installer des outils de surveillance optionnels

Pour observer le comportement du cache, installez LangSmith pour le traçage :

pip install langsmith
export LANGCHAIN_TRACING_V2="true"
export LANGCHAIN_API_KEY="votre-clé-api-langsmith"

Configuration pour la mise en cache des prompts

La mise en cache des prompts est généralement activée au niveau du fournisseur de modèle. Voici comment la configurer pour les principaux fournisseurs.

OpenAI

OpenAI met automatiquement en cache les prompts de 1 024 tokens ou plus. Vous pouvez optimiser en structurant votre prompt système comme un préfixe réutilisable :

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
    # La mise en cache est automatique ; aucun indicateur spécial n'est nécessaire
)

Anthropic

Anthropic nécessite des en-têtes de contrôle de cache explicites. Utilisez le paramètre `cache_control` dans votre prompt :

from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(
    model="claude-3-5-sonnet-20241022",
    temperature=0,
)

# Dans votre prompt, marquez les sections pouvant être mises en cache :
system_prompt = [
    {
        "type": "text",
        "text": "Vous êtes un assistant utile doté de capacités de raisonnement approfondi.",
        "cache_control": {"type": "ephemeral"}
    }
]

Microsoft Azure OpenAI

Azure OpenAI prend en charge la mise en cache des prompts à partir de GPT-4o-mini. Activez-la via votre déploiement :

from langchain_openai import AzureChatOpenAI

llm = AzureChatOpenAI(
    azure_deployment="gpt-4o-mini",
    api_version="2024-08-01-preview",
    temperature=0,
)
# La mise en cache est automatique pour les prompts >= 1 024 tokens

Construction d'un agent profond avec mise en cache des prompts

Créons maintenant un agent profond qui bénéficie de la mise en cache. Nous allons construire un assistant de recherche effectuant une analyse en plusieurs étapes.

Étape 1 : Définir le prompt système

Créez un prompt système long et réutilisable qui sera mis en cache :

system_prompt = """
Vous êtes un assistant de recherche spécialisé dans l'analyse de documents techniques.
Vos capacités :
- Résumer des textes longs
- Extraire les résultats clés
- Comparer et contraster des sources
- Identifier les lacunes dans les arguments
- Suggérer des lectures complémentaires

Répondez toujours dans un format structuré :
1. Résultats principaux
2. Preuves
3. Conclusions

Soyez minutieux et citez des exemples spécifiques du texte.
"""

Étape 2 : Créer l'agent avec mise en cache

Utilisez le contrôle de cache d'Anthropic pour une mise en cache explicite :

from langchain.agents import create_openai_functions_agent
from langchain.tools import tool
from langchain_anthropic import ChatAnthropic
from langgraph.graph import StateGraph, MessagesState

@tool
def search_database(query: str) -> str:
    """Rechercher dans la base de données interne les documents pertinents."""
    # Recherche simulée
    return f"Résultats pour '{query}' : 3 documents pertinents trouvés."

@tool
def extract_insights(text: str) -> str:
    """Extraire les informations clés d'un texte donné."""
    return f"Informations clés : {text[:100]}..."

llm = ChatAnthropic(
    model="claude-3-5-sonnet-20241022",
    temperature=0,
)

# Créer l'agent avec contrôle de cache
prompt = system_prompt + "\n\nRequête utilisateur : {input}\n\nHistorique de conversation : {chat_history}"

tools = [search_database, extract_insights]

# Encapsuler le prompt avec le contrôle de cache
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

prompt_template = ChatPromptTemplate.from_messages([
    ("system", system_prompt, {"cache_control": {"type": "ephemeral"}}),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}"),
])

agent = create_openai_functions_agent(llm, tools, prompt_template)

Étape 3 : Ajouter un graphe pour le raisonnement profond

Utilisez LangGraph pour créer un agent multi-étapes qui réutilise le prompt système mis en cache :

from langgraph.graph import StateGraph, END
from typing import TypedDict, List, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[List, operator.add]
    step_count: int

def call_model(state: AgentState):
    # Le prompt système est mis en cache, donc les appels répétés sont rapides
    response = agent.invoke({
        "input": state["messages"][-1].content,
        "chat_history": state["messages"][:-1]
    })
    return {"messages": [response], "step_count": state["step_count"] + 1}

def should_continue(state: AgentState):
    # S'arrêter après 5 étapes ou si l'agent décide de terminer
    if state["step_count"] >= 5:
        return "end"
    return "continue"

# Construire le graphe
graph = StateGraph(AgentState)
graph.add_node("agent", call_model)
graph.add_conditional_edges(
    "agent",
    should_continue,
    {"continue": "agent", "end": END}
)
graph.set_entry_point("agent")

app = graph.compile()

Exemples d'utilisation

Exemple 1 : Agent de base avec cache

Exécutez une requête qui bénéficie du prompt système mis en cache :

# Première requête (le prompt système est mis en cache)
result = app.invoke({
    "messages": [{"role": "user", "content": "Résumez les résultats clés de notre rapport du T3."}],
    "step_count": 0
})
print("Première réponse :", result["messages"][-1].content)

# Deuxième requête (succès du cache - beaucoup plus rapide)
result2 = app.invoke({
    "messages": [{"role": "user", "content": "Comparez ces résultats avec ceux du T2."}],
    "step_count": 0
})
print("Deuxième réponse :", result2["messages"][-1].content)

Exemple 2 : Surveillance des performances du cache

Utilisez LangSmith pour observer les succès du cache et les améliorations de latence :

import time

# Activer le traçage détaillé
from langsmith import Client
client = Client()

# Exécuter plusieurs requêtes et mesurer
for i in range(3):
    start = time.time()
    result = app.invoke({
        "messages": [{"role": "user", "content": f"Analysez l'ensemble de documents {i+1}."}],
        "step_count": 0
    })
    elapsed = time.time() - start
    print(f"Requête {i+1} : {elapsed:.2f}s")

Exemple 3 : Optimisation pour un maximum de succès du cache

Structurez vos prompts pour maximiser la réutilisation du cache :

# Utilisez toujours le même préfixe de prompt système
cached_prefix = """
Vous êtes un assistant de recherche.
Vos rôles :
- Résumer
- Extraire
- Comparer

"""

# Ne faites varier que le message utilisateur
queries = [
    "Résumez le rapport du T1.",
    "Extrayez les métriques clés du T1.",
    "Comparez les tendances du T1 et du T2."
]

for query in queries:
    response = agent.invoke({
        "input": query,
        "chat_history": []
    })
    print(f"Requête : {query}")
    print(f"Réponse : {response.content[:50]}...")
    print("---")

Bonnes pratiques

1. **Concevez des prompts système longs et stables** : La mise en cache fonctionne mieux lorsque le préfixe du prompt reste inchangé entre les requêtes. Gardez les instructions système et les définitions d'outils constantes.

2. **Utilisez des versions de modèles appropriées** : GPT-4o-mini d'OpenAI et Claude 3.5 Sonnet d'Anthropic offrent les meilleures performances de mise en cache. Consultez la documentation du fournisseur pour les modèles pris en charge les plus récents.

3. **Surveillez les taux de succès du cache** : Utilisez LangSmith ou les tableaux de bord des fournisseurs pour suivre la fréquence à laquelle vos prompts atteignent le cache. Visez un taux de succès >50 % pour des économies de coûts significatives.

4. **Envisagez le traitement par lots** : Lorsque vous traitez des requêtes similaires, structurez-les pour partager des préfixes communs. Cela maximise la réutilisation du cache entre les requêtes.

5. **Testez avec des charges de travail réalistes** : Les performances du cache dépendent de la longueur et de la répétition des prompts. Effectuez des benchmarks avec votre cas d'utilisation réel avant de déployer en production.

Conclusion

La mise en cache des prompts est une technique puissante qui réduit considérablement le coût et la latence des systèmes d'agents profonds. En stockant et en réutilisant les segments de prompts déjà traités, vous pouvez obtenir des temps de réponse 2 à 5 fois plus rapides tout en réduisant les coûts d'API de 30 à 60 %. La clé est de concevoir vos prompts d'agent en gardant la mise en cache à l'esprit — utilisez des prompts système longs et stables, tirez parti des fonctionnalités de mise en cache spécifiques au fournisseur, et surveillez les performances avec des outils comme LangSmith.

Alors que les fournisseurs de LLM continuent d'améliorer leur infrastructure de mise en cache (mise en cache automatique d'OpenAI, contrôle de cache explicite d'Anthropic et intégration de Microsoft Azure), les agents profonds deviendront encore plus pratiques et économiques. Commencez à implémenter la mise en cache des prompts dès aujourd'hui pour débloquer des applications d'IA plus rapides, moins chères et plus évolutives.

*Pour les dernières mises à jour sur les techniques de mise en cache des prompts, consultez les blogs officiels de LangChain, OpenAI, Microsoft et Anthropic.*