Salut, agent en formation ! Emma ici, de retour sur agent101.net, et aujourd’hui, nous allons nous plonger dans quelque chose qui me trotte dans la tête (et dans mon environnement de développement) depuis des semaines : comment faire en sorte que votre agent IA se rappelle vraiment des choses. Pas seulement se souvenir pour une tâche, mais conserver ce contexte, ces apprentissages, cette personnalité à travers plusieurs interactions. Parce qu’en toute honnêteté, un agent distrait n’est qu’un script sophistiqué, n’est-ce pas ?
La date actuelle est le 25 mars 2026, et le monde des agents IA évolue à une vitesse incroyable. 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 attendons de nos agents qu’ils 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. Il ne s’agit pas de créer une AGI parfaitement développée (pas encore !), mais de rendre vos agents IA quotidiens et pratiques plus utiles, plus intelligents, et moins comme Dory dans Le Monde de Nemo.
J’ai expérimenté divers frameworks d’agents, de LangChain à AutoGen, et un obstacle constant pour les débutants (et, honnêtement, pour moi parfois !) est la gestion de l’état et de la mémoire de manière efficace. C’est souvent négligé dans les tutoriels de base, qui ont tendance à se concentrer sur une simple boucle prompt-réponse. 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 continue-t-il d’oublier de quoi nous avons parlé ?
Imaginez ceci : j’essayais de créer un agent simple pour m’aider à brainstormer des idées d’articles de blog. Mon installation initiale était assez basique : je lui donnais un sujet, et il me sortait des idées. Super pour des prompts ponctuels. Mais ensuite, je disais : « D’accord, maintenant développe l’idée numéro trois, » et il me regardait (au sens figuré) avec un regard vide, me demandant : « Quelle idée numéro trois ? » C’était frustrant ! Cela signifiait que je devais constamment redonner le contexte, rendant l’interaction maladroite et inefficace.
Cette « distraction » provient de la nature sans état de la plupart des grands modèles de langage (LLMs) à leur cœur. Chaque appel d’API est souvent traité comme une demande fraîche. Il ne se souvient pas intrinsèquement de l’historique des conversations 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 conserver. C’est là qu’intervient la mémoire.
Les deux grandes catégories de mémoire des agents : mémoire à court terme et mémoire à long terme
Quand nous parlons d’un agent IA « se souvenant », nous parlons généralement de deux types principaux de mémoire, un peu comme notre propre mémoire :
Mémoire à court terme : Le tampon de conversation
C’est le type de mémoire le plus simple et celui avec lequel la plupart des débutants devraient commencer. La mémoire à court terme concerne le souvenir du passé immédiat – de la conversation actuelle. Pensez-y comme votre mémoire de travail lorsque vous discutez avec un ami. Vous vous souvenez de ce qui a été dit récemment, de qui a dit quoi, et du fil 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 offrent des moyens simples de mettre cela en œuvre.
Exemple pratique : ConversationBufferMemory de LangChain
Voyons un exemple basique en Python utilisant LangChain. Cela dé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 simple modèle de prompt
template = """You are a friendly AI assistant.
Current conversation:
{chat_history}
Human: {input}
AI:"""
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, # Permet de 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"AI: {response1['text']}")
# Deuxième interaction, remarquez comment 'chat_history' est automatiquement passé
print("\n--- Interaction 2 ---")
response2 = conversation_chain.invoke({"input": "Peux-tu me raconter un fait amusant sur l'IA ?" })
print(f"AI: {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"AI: {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.
- Le `PromptTemplate` inclut une variable `{chat_history}`.
- Lorsque `conversation_chain.invoke()` est appelé, LangChain injecte automatiquement l’historique de conversation stocké dans le prompt avant de l’envoyer au LLM.
C’est super pour des conversations courtes. Mais que se passe-t-il si votre conversation s’éternise ? 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, vous atteindrez soit 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 interviennent, comme `ConversationBufferWindowMemory` (se souvient seulement des N dernières interactions) ou `ConversationSummaryBufferMemory` (résume les anciennes parties 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 devrait conserver à travers les sessions ou même à travers différentes tâches. C’est là que les choses deviennent vraiment intéressantes et puissantes.
Mon exemple d’agent de brainstorming d’articles de blog est un cas parfait 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 passés qui ont bien fonctionné, afin qu’il ne suggère pas quelque chose de complètement hors sujet à chaque fois. Je ne veux pas lui expliquer agent101.net tous les jours !
La manière la plus courante d’implémenter la mémoire à long terme implique actuellement deux composants clés :
- Modèles d’insertion : Ces modèles convertissent le texte (votre connaissance, vos interactions passées, etc.) en vecteurs numériques. Les textes ayant des significations similaires auront des vecteurs qui sont numériquement « proches » 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 stockage 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 augmentez le prompt du LLM avec.
Exemple pratique : Utiliser un stockage 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 cette information dans un stockage 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 la 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 lorsque cela est possible.
Son public principal est constitué d'individus nouvellement familiarisés avec les agents IA ou à la recherche de conseils pratiques d'implémentation.
Les sujets clés incluent : LangChain, AutoGen, ingénierie des prompts pour les agents, gestion de la mémoire, utilisation des outils.
Elle vise à démystifier 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 vectoriel
# 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 vectoriel
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 basée sur le 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("--- Requête 1 ---")
query1 = "Qui es-tu et de quoi écris-tu ?"
result1 = qa_chain.invoke({"query": query1})
print(f"IA : {result1['result']}")
print("\n--- Requête 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--- Requête 3 (Connaissance Externe) ---")
query3 = "Quelle est la capitale de la France ?" # Cette information n'est pas dans notre info persona
result3 = qa_chain.invoke({"query": query3})
print(f"IA : {result3['result']}") # Elle devrait quand même répondre car le LLM a des connaissances générales,
# mais si nous voulions strictement *uniquement* le contexte, nous ajusterions le prompt.
# Note importante : Si vous souhaitez que l'agent respecte 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 vectoriel 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` comme `{context}`.
- Enfin, le LLM a utilisé ce prompt amélioré 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 (PDF, 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 d’agents réussies passées ou des stratégies de planification.
Mon avis personnel sur le démarrage avec la mémoire
Lorsque j’ai commencé, j’ai essayé de tout construire de zéro, pensant que j’étais intelligent. J’ai rapidement appris qu’utiliser des cadres établis comme LangChain ou AutoGen (qui ont leurs propres concepts de mémoire, souvent via l’historique des messages de l’agent) est la meilleure solution. Ils gèrent beaucoup de code répétitif pour vous.
Mon conseil pour les débutants :
- Commencez avec `ConversationBufferMemory`. C’est le plus simple et cela rendra immédiatement vos agents plus conversationnels.
- Comprenez les limites de la fenêtre de contexte. Si vos conversations deviennent longues, passez à `ConversationBufferWindowMemory` ou `ConversationSummaryBufferMemory` pour éviter la troncation ou des coûts API excessifs.
- Ne vous lancez pas directement dans des systèmes RAG complexes. Familiarisez-vous d’abord avec la mémoire de chat basique. Une fois que vous voyez la nécessité d’une connaissance persistante ou d’un rappel de faits spécifiques, explorez alors les magasins vectoriels.
- Faites attention à l’ingénierie des prompts pour le RAG. La manière dont vous demandez au LLM d’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 rassembler toute l’histoire de vie de votre agent dans le `chat_history`. Réservez `chat_history` pour l’interaction actuelle et utilisez le RAG pour tout le reste.
Un défi que j’ai rencontré était de gérer la mémoire à travers plusieurs *sessions*. Si mon agent redémarrait, sa `ConversationBufferMemory` était perdue. Pour une mémoire à court terme véritablement persistante (par exemple, si vous souhaitez reprendre une conversation là où vous vous étiez arrêté hier), vous devrez sérialiser et stocker votre objet `memory` (par exemple, sous la forme d’un fichier JSON ou dans une base de données) et le charger lorsque l’agent démarre. Cela ajoute une couche supplémentaire de complexité, mais c’est tout à fait réalisable une fois que vous maîtrisez les bases.
Points d’action pour votre prochain projet d’agent
Vous avez la théorie, maintenant allez construire ! Voici ce que je veux que vous fassiez ensuite :
- Sélectionnez un projet d’agent simple existant (ou commencez-en un nouveau) que vous avez construit et qui actuellement “oublie” des choses.
- Implémentez `ConversationBufferMemory` pour lui donner une mémoire à court terme basique. Voyez à quel point la conversation devient plus naturelle.
- Pensez à quelles connaissances persistantes votre agent pourrait avoir besoin. S’agit-il d’un ensemble d’instructions spécifiques ? 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 le persona souhaité de votre agent ou quelques faits) et stockez-le dans un magasin vectoriel local `FAISS`. Voyez si votre agent peut récupérer et utiliser cette information.
- Surveillez votre utilisation des tokens ! N’oubliez pas, envoyer de longs historiques de chat ou de nombreux documents récupérés augmente votre compte de tokens, 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 seulement un détail technique ; c’est ce qui transforme une interaction froide et transactionnelle en quelque chose qui semble réellement utile et intelligent. C’est la différence entre un outil et un véritable assistant. Allez rendre 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
- Les Fondamentaux de l’IA : Un Guide Pratique pour Commencer en 2026
🕒 Published: