Agents IA : le dilemme entre mémoire et efficacité

Introduction

Dans le domaine de l'intelligence artificielle, la gestion de l'état d'un agent est cruciale pour déterminer son efficacité et son adaptabilité. Deux approches principales se distinguent : les agents sans état et les agents avec état. Cet article explore comment ces deux conceptions influencent l'implémentation et l'architecture de déploiement des systèmes agentiques.

Nous allons examiner les différences fondamentales entre ces deux types d'agents et les compromis qu'ils imposent à grande échelle. Nous aborderons également les méthodes d'implémentation pour chaque type d'agent, en mettant l'accent sur les agents sans état qui s'appuient sur le client pour l'historique des conversations, et les agents avec état qui utilisent une base de données pour gérer leur mémoire.

Configuration initiale

Pour ceux qui découvrent les modèles de langage Groq dans un environnement Python, la première étape consiste à installer la bibliothèque nécessaire avec la commande pip install groq. Une fois cette installation effectuée, il est essentiel d'importer la bibliothèque et de définir la clé API Groq dans votre code.

import os
from groq import Groq

# Obtenez une clé API sur https://console.groq.com/keys et définissez-la ici
os.environ["GROQ_API_KEY"] = "COLLEZ_VOTRE_CLE_API_GROQ_ICI"

# Initialisation du client
client = Groq()

# Utilisation d'un modèle efficace de Groq : Llama 3.1 8B Instant
MODEL_ID = "[llama](/dossier/meta-ia)-3.1-8b-instant"

Un choix crucial dans cette configuration est le modèle utilisé. Le modèle llama-3.1-8b-instant est particulièrement avantageux grâce à son coût réduit et sa compatibilité avec le niveau gratuit de Groq, qui permet jusqu'à 14 400 requêtes par jour. Ce modèle est idéal pour illustrer les paradigmes d'agents sans état et avec état.

Agents sans état : Fire and Forget

Les agents sans état traitent chaque interaction comme une entité distincte, sans conserver de mémoire des échanges précédents. Lorsqu'un utilisateur soumet une requête, l'agent lit le prompt, utilise le moteur d'inférence du modèle de langage, puis fournit une réponse. Une fois ce processus terminé, il n'y a aucune rétention d'information.

Le compromis

L'un des principaux avantages des agents sans état est leur capacité à s'étendre horizontalement de manière efficace. Puisqu'ils ne stockent aucune donnée utilisateur sur le serveur, les requêtes peuvent être dirigées vers n'importe quelle instance disponible. Cependant, cette approche présente une limitation significative pour les conversations à plusieurs tours : le client doit renvoyer l'historique complet de la conversation à chaque nouvelle requête, ce qui augmente rapidement la fenêtre de contexte et l'utilisation des tokens.

Exemple illustratif

Voici un exemple de code qui démontre comment un agent sans état interagit avec un modèle de langage Groq. La fonction stateless_agent montre comment l'agent dépend entièrement du client pour le contexte conversationnel.

def stateless_agent(prompt: str, provided_history: list = None) -> str:
    """
    L'agent dépend entièrement du client pour fournir le contexte.
    Il ne conserve aucune information des interactions passées dans la mémoire locale.
    """
    # Initialisation avec un prompt système
    messages = [{"role": "system", "content": "Vous êtes un assistant utile et concis."}]
    
    # Ajout de l'historique fourni par le client
    if provided_history:
        messages.extend(provided_history)
    
    # Ajout du nouveau prompt
    messages.append({"role": "user", "content": prompt})
    
    # Le LLM traite l'ensemble de la chaîne de messages
    response = client.chat.completions.create(
        model=MODEL_ID,
        messages=messages,
        max_tokens=100
    )
    return response.choices[0].message.content.strip()

Pour illustrer les limitations de cette approche, nous simulons une conversation simple entre un utilisateur et le modèle.

# --- Test de l'Agent Sans État ---
print("--- Tour 1 ---")
prompt_1 = "Bonjour, je m'appelle Alice et j'apprends sur l'infrastructure API."
response_1 = stateless_agent(prompt_1)
print(f"Agent : {response_1}")

print("\n--- Tour 2 (Sans Contexte Client) ---")
# L'agent échoue ici car il n'a retenu aucune mémoire du Tour 1
prompt_2 = "Quel est mon nom et qu'est-ce que j'apprends ?"
response_2 = stateless_agent(prompt_2)
print(f"Agent : {response_2}")

print("\n--- Tour 2 (Avec Contexte Client) ---")
# Le frontend DOIT injecter l'historique dans la charge utile pour que l'agent réussisse
frontend_payload = [
    {"role": "user", "content": prompt_1},
    {"role": "assistant", "content": response_1}
]
response_3 = stateless_agent(prompt_2, provided_history=frontend_payload)
print(f"Agent : {response_3}")

Agents avec état : Continuité axée sur le contexte

Les agents avec état, en revanche, prennent en charge la mémoire conversationnelle. Le client n'a besoin d'envoyer que le dernier prompt utilisateur avec un identifiant unique lié à la session. L'agent récupère ensuite l'historique de la session à partir d'une base de données et y ajoute le nouveau message. Après le traitement par le modèle de langage, l'agent met à jour le contexte dans la base de données.

Le compromis

Cette approche offre une expérience utilisateur plus fluide et permet de gérer des flux de travail plus complexes et asynchrones. Cependant, elle nécessite une infrastructure plus lourde, notamment une base de données persistante. Dans des systèmes qui s'étendent horizontalement, des solutions comme la mise en cache centralisée avec Redis peuvent être nécessaires pour éviter que l'historique d'une session ne soit bloqué sur une seule instance.