Salut, agent en formation ! Emma ici, de retour sur agent101.net, et aujourd’hui nous allons plonger dans quelque chose qui me trotte dans la tête (et dans mon environnement de développeur) depuis des semaines : comment faire en sorte que votre agent IA *se souvienne* réellement des choses. Pas seulement se souvenir pour une tâche, mais porter ce contexte, ces apprentissages, cette personnalité à travers plusieurs interactions. Parce qu’en toute vérité, un agent oublieux n’est qu’un script sophistiqué, non ?
La date actuelle est le 25 mars 2026, et le monde des agents IA avance à une vitesse fulgurante. Il y a un an ou deux, nous étions impressionnés par un chatbot capable de tenir une conversation décente pendant cinq minutes. Maintenant ? Nous nous attendons à ce que nos agents soient nos compagnons numériques, nos assistants de recherche, nos réviseurs de code, et ils doivent donner l’impression de nous connaître, ou du moins de savoir ce qu’ils font. Cela ne concerne pas la construction d’une AGI complète (pas encore !), mais de rendre vos agents IA quotidiens, pratiques, plus utiles, plus intelligents et moins ressemblants à Dory de Le Monde de Nemo.
J’ai expérimenté avec divers frameworks d’agents, de LangChain à AutoGen, et un obstacle constant pour les débutants (et, honnêtement, pour moi parfois !) est de gérer efficacement l’état et la mémoire. Cela est souvent négligé dans les tutoriels de base, qui ont tendance à se concentrer sur une boucle de prompt-réponse unique. Mais si vous voulez que votre agent s’appuie sur ses actions précédentes, apprenne de ses erreurs, ou même se souvienne de votre nom après la première interaction, vous avez besoin d’une stratégie.
Pourquoi Mon Agent Oublie-t-il Ce Dont Nous Venons de Parler ?
Imaginez ceci : j’essayais de construire un agent simple pour m’aider à réfléchir à des idées de posts de blog. Ma configuration initiale était assez basique : je lui donnais un sujet, et il me balançait des idées. Super pour des prompts uniques. Mais ensuite, je disais : « D’accord, maintenant développe l’idée numéro trois, » et il me regardait (au sens figuré) avec un air vide, demandant : « Quelle idée numéro trois ? » C’était frustrant ! Cela signifiait que je devais sans cesse fournir à nouveau le contexte, rendant l’interaction maladroite et inefficace.
Cette « oubli » provient de la nature sans état de la plupart des modèles de langage à grande échelle (LLMs) à leur cœur. Chaque appel d’API est souvent considéré comme une nouvelle requête. Il ne se souvient pas intrinsèquement de l’historique de la conversation ou des résultats des appels précédents. Les frameworks d’agents existent pour orchestrer ces appels, mais vous, le développeur, êtes responsable de décider quelles informations transmettre. C’est là qu’intervient la mémoire.
Les Deux Grands Types de Mémoire d’Agent : Court Terme et Long Terme
Lorsque nous parlons d’un agent IA « se souvenant », nous parlons généralement de deux types principaux de mémoire, un peu comme la nôtre :
Mémoire à Court Terme : Le Tampon de Conversation
C’est le type de mémoire le plus simple et ce avec quoi la plupart des débutants devraient commencer. La mémoire à court terme consiste à se souvenir du passé immédiat – la conversation en cours. Pensez-y comme à votre mémoire de travail lorsque vous discutez avec un ami. Vous vous souvenez de ce qui vient d’être dit, qui a dit quoi, et du déroulement général de la discussion.
Pour un agent IA, cela signifie généralement stocker l’échange récent de messages (prompts et réponses) et les envoyer avec chaque nouveau prompt au LLM. La plupart des frameworks d’agents proposent des moyens simples d’implémenter cela.
Exemple Pratique : ConversationBufferMemory de LangChain
Regardons un exemple Python basique utilisant LangChain. Cela montre comment garder une simple historique de conversation.
from langchain.memory import ConversationBufferMemory
from langchain_openai import ChatOpenAI
from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
# Initialiser votre LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
# Initialiser la mémoire
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
# Définir un modèle de prompt simple
template = """Vous êtes un assistant IA amical.
Conversation actuelle :
{chat_history}
Humain : {input}
IA :"""
prompt = PromptTemplate(input_variables=["chat_history", "input"], template=template)
# Créer la chaîne de conversation
conversation_chain = LLMChain(
llm=llm,
prompt=prompt,
verbose=True, # Aide à voir ce qui se passe
memory=memory
)
# Première interaction
print("--- Interaction 1 ---")
response1 = conversation_chain.invoke({"input": "Salut, je m'appelle Emma. Et toi ?"})
print(f"IA : {response1['text']}")
# Deuxième interaction, remarquez comment 'chat_history' est automatiquement passé
print("\n--- Interaction 2 ---")
response2 = conversation_chain.invoke({"input": "Peux-tu me dire un fait amusant sur l'IA ?"})
print(f"IA : {response2['text']}")
# Troisième interaction, l'agent se souvient de mon nom !
print("\n--- Interaction 3 ---")
response3 = conversation_chain.invoke({"input": "Merci ! Au fait, quel âge a Emma ?"})
print(f"IA : {response3['text']}")
print("\n--- État Final de la Mémoire ---")
print(memory.load_memory_variables({}))
Que se passe-t-il ici ?
- `ConversationBufferMemory` stocke les messages au fur et à mesure qu’ils arrivent.
- Le `PromptTemplate` inclut une variable `{chat_history}`.
- Lorsque `conversation_chain.invoke()` est appelé, LangChain injecte automatiquement la `chat_history` stockée dans le prompt avant de l’envoyer au LLM.
C’est super pour des conversations brèves. Mais que se passe-t-il si votre conversation dure longtemps ? Les LLM ont des fenêtres de contexte (une limite sur la quantité de texte qu’ils peuvent traiter à la fois). Si votre historique de chat devient trop long, soit vous atteindrez cette limite et obtiendrez une erreur, soit les parties plus anciennes de la conversation seront tronquées. C’est là que des stratégies de mémoire à court terme plus avancées entrent en jeu, comme `ConversationBufferWindowMemory` (se souvient seulement des N dernières interactions) ou `ConversationSummaryBufferMemory` (résume les parties plus anciennes de la conversation pour économiser de l’espace).
Mémoire à Long Terme : Base de Connaissances et Stockages de Vecteurs
La mémoire à court terme concerne le chat immédiat. La mémoire à long terme concerne les connaissances persistantes, les faits, les expériences passées, ou même une « personnalité » apprise qu’un agent doit conserver à travers les sessions ou même à travers différentes tâches. C’est ici que les choses deviennent vraiment intéressantes et puissantes.
Mon exemple d’agent de brainstorming pour les posts de blog est un parfait cas d’utilisation pour la mémoire à long terme. Je veux qu’il se souvienne de mon style préféré, de ma niche (les agents IA pour les débutants), et même des sujets réussis du passé, afin qu’il ne propose pas quelque chose de complètement hors sujet à chaque fois. Je ne veux pas avoir à lui expliquer agent101.net chaque jour !
La manière la plus courante d’implémenter la mémoire à long terme en ce moment implique deux composants clés :
- Modèles d’Intégration : Ces modèles convertissent le texte (vos connaissances, interactions passées, etc.) en vecteurs numériques. Les textes ayant des significations similaires auront des vecteurs « proches » numériquement les uns des autres.
- Stockages de Vecteurs (ou Bases de Données de Vecteurs) : Ce sont des bases de données spécialisées conçues pour stocker et rechercher efficacement ces vecteurs numériques. Lorsque vous avez une nouvelle requête ou un nouveau contexte, vous le convertissez en vecteur, puis vous recherchez dans le stock de vecteurs les vecteurs existants les plus similaires. Le texte associé à ces vecteurs similaires est ensuite récupéré et peut être injecté dans votre prompt.
Ce processus est souvent appelé Génération Augmentée par Récupération (RAG). Vous récupérez des informations pertinentes de votre mémoire à long terme et enrichissez le prompt du LLM avec cela.
Exemple Pratique : Utilisation d’un Stock de Vecteurs pour la Personnalité de l’Agent
Imaginons que nous voulons que notre agent ait une « persona » cohérente ou accède à une base de connaissances sur notre marque. Nous pouvons stocker ces informations dans un stock de vecteurs.
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_community.vectorstores import FAISS
from langchain.chains import RetrievalQA
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.prompts import PromptTemplate
# 1. Définir notre 'connaissance à long terme' (par exemple, persona de l'agent, directives de marque)
# Dans un scénario réel, cela serait chargé à partir d'un fichier, d'une base de données, etc.
brand_persona_info = """
Le nom de l'agent est Emma. Elle écrit pour agent101.net.
Son style d'écriture est amical, pratique, et se concentre sur l'aide aux débutants pour comprendre les agents IA.
Elle utilise des anecdotes et évite le jargon technique excessif quand c'est possible.
Son public principal est constitué de personnes nouvelles aux agents IA ou cherchant des conseils pratiques d'implémentation.
Les sujets clés incluent : LangChain, AutoGen, ingénierie de prompt pour agents, gestion de la mémoire, utilisation d'outils.
Elle vise à démythifier des concepts IA complexes.
"""
# 2. Diviser le texte en morceaux gérables (pour les documents plus volumineux)
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
docs = text_splitter.create_documents([brand_persona_info])
# 3. Créer des embeddings et les stocker dans un magasin de vecteurs
# FAISS est une bonne option locale pour les débutants. Pour la production, vous utiliseriez Pinecone, Chroma, etc.
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(docs, embeddings)
# 4. Initialiser le LLM
llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.5)
# 5. Créer un récupérateur à partir du magasin de vecteurs
retriever = vectorstore.as_retriever()
# 6. Définir un modèle de prompt personnalisé pour la chaîne RAG
# Nous disons explicitement au LLM d'utiliser le contexte fourni.
custom_prompt_template = """Utilisez le contexte suivant pour répondre à la question de l'utilisateur.
Si vous ne connaissez pas la réponse en fonction du contexte, dites simplement que vous ne savez pas, ne tentez pas d'inventer une réponse.
Contexte :
{context}
Question : {question}
"""
custom_prompt = PromptTemplate(
template=custom_prompt_template,
input_variables=["context", "question"]
)
# 7. Créer la chaîne RAG
qa_chain = RetrievalQA.from_chain_type(
llm=llm,
chain_type="stuff", # 'stuff' signifie mettre tous les documents récupérés dans le prompt
retriever=retriever,
return_source_documents=True,
chain_type_kwargs={"prompt": custom_prompt}
)
# Maintenant, interrogeons l'agent
print("--- Question 1 ---")
query1 = "Qui es-tu et de quoi écris-tu ?"
result1 = qa_chain.invoke({"query": query1})
print(f"IA : {result1['result']}")
print("\n--- Question 2 ---")
query2 = "Quel est le style d'écriture préféré d'Emma ?"
result2 = qa_chain.invoke({"query": query2})
print(f"IA : {result2['result']}")
print("\n--- Question 3 (Connaissance extérieure) ---")
query3 = "Quelle est la capitale de la France ?" # Cette information n'est pas dans notre persona
result3 = qa_chain.invoke({"query": query3})
print(f"IA : {result3['result']}") # Elle devrait toujours répondre car le LLM a des connaissances générales,
# mais si nous voulions strictement *uniquement* le contexte, nous ajusterions le prompt.
# Remarque importante : Si vous voulez que l'agent adhère strictement à *uniquement* le contexte fourni
# et refuse de répondre si le contexte ne contient pas la réponse, vous devez être très
# explicite dans votre custom_prompt_template. Par exemple : "Basé UNIQUEMENT sur le contexte suivant..."
Décomposition de l’exemple RAG :
- Nous avons pris notre texte de “persona”.
- Nous l’avons divisé en morceaux (important pour les documents plus volumineux).
- Nous avons utilisé `OpenAIEmbeddings` pour transformer ces morceaux en vecteurs numériques.
- `FAISS` (un magasin de vecteurs local) a stocké ces vecteurs.
- Lorsque nous avons posé une question, le `retriever` a recherché dans `FAISS` les morceaux de texte les plus pertinents.
- Ces morceaux pertinents ont ensuite été insérés dans notre `custom_prompt_template` en tant que `{context}`.
- Enfin, le LLM a utilisé ce prompt enrichi pour répondre à la question, donnant l’impression qu’il “se souvenait” de sa persona.
Cette approche est incroyablement flexible. Vous pouvez l’utiliser pour :
- Stocker des documents (PDFs, articles, wikis internes).
- Se souvenir des préférences des utilisateurs au fil du temps.
- Maintenir la “personnalité” d’un agent ou des instructions spécifiques.
- Stocker les actions réussies passées de l’agent ou des stratégies de planification.
Mon avis personnel sur le démarrage avec la mémoire
Quand j’ai commencé, j’ai essayé de tout construire à partir de zéro, pensant que j’étais intelligent. J’ai rapidement appris que l’utilisation de cadres établis comme LangChain ou AutoGen (qui a ses propres concepts de mémoire, souvent via l’historique des messages de l’agent) est la meilleure approche. Ils gèrent une grande partie du code standard pour vous.
Mon conseil pour les débutants :
- Commencez avec `ConversationBufferMemory`. C’est le plus simple et cela fera immédiatement sentir à vos agents un dialogue plus naturel.
- Comprendre les limites de la fenêtre de contexte. Si vos conversations deviennent longues, passez à `ConversationBufferWindowMemory` ou `ConversationSummaryBufferMemory` pour éviter la troncature ou des coûts API excessifs.
- Ne sautez pas directement dans des systèmes RAG complexes. Familiarisez-vous d’abord avec la mémoire de chat de base. Une fois que vous voyez le besoin d’une connaissance persistante ou d’un rappel factuel spécifique, explorez alors les magasins de vecteurs.
- Faites attention à l’ingénierie de prompt pour RAG. La manière dont vous instructez le LLM à utiliser le contexte récupéré est cruciale. Expérimentez avec des phrases comme “Utilisez UNIQUEMENT le contexte suivant,” ou “Complétez vos connaissances avec le contexte suivant.”
- Séparez les besoins à court terme et à long terme. Ne tentez pas de tasser l’intégralité de l’histoire de vie de votre agent dans le `chat_history`. Réservez `chat_history` pour l’interaction actuelle et utilisez RAG pour tout le reste.
Un défi auquel j’ai été confronté était de gérer la mémoire à travers plusieurs *sessions*. Si mon agent redémarrait, sa `ConversationBufferMemory` était perdue. Pour une véritable mémoire à court terme persistante (par exemple, si vous voulez reprendre une conversation là où vous vous êtes arrêté hier), vous devez sérialiser et stocker votre objet `memory` (par exemple, en tant que fichier JSON ou dans une base de données) et le recharger lorsque l’agent démarre. Cela ajoute une autre couche de complexité, mais c’est tout à fait faisable une fois que vous avez compris les bases.
Points d’action pour votre prochain projet d’agent
Vous avez la théorie, maintenant construisez ! Voici ce que je veux que vous fassiez ensuite :
- Sélectionnez un projet d’agent simple existant (ou commencez un nouveau) que vous avez construit qui ’oublie’ actuellement des choses.
- Mettez en œuvre `ConversationBufferMemory` pour lui donner un rappel à court terme de base. Voyez à quel point la conversation devient plus naturelle.
- Pensez à la connaissance persistante dont votre agent pourrait avoir besoin. S’agit-il d’un ensemble spécifique d’instructions ? D’une préférence personnelle ? D’une base de connaissances ?
- Expérimentez avec une configuration RAG simple. Prenez un petit morceau de texte (comme la persona souhaitée de votre agent ou quelques faits) et stockez-le dans un magasin de vecteurs `FAISS` local. Voyez si votre agent peut récupérer et utiliser cette information.
- Surveillez votre utilisation de jetons ! N’oubliez pas, l’envoi d’histoires de chat longues ou de nombreux documents récupérés augmente votre nombre de jetons, ce qui impacte directement le coût et la latence. Optimisez votre stratégie de mémoire au fur et à mesure.
Faire en sorte que votre agent IA se souvienne n’est pas qu’un détail technique ; c’est ce qui transforme une interaction froide et transactionnelle en quelque chose qui semble véritablement utile et intelligent. C’est la différence entre un outil et un véritable assistant. Rendez vos agents plus intelligents et n’oubliez pas de partager vos progrès sur les forums agent101.net !
Articles connexes
- Le coût de NE PAS utiliser des agents IA en 2026
- Outils principaux pour le développement d’agents IA
- Fondamentaux de l’IA : Un guide pratique pour commencer en 2026
🕒 Published: