J’ai construit une IA qui se souvient : Mon parcours vers la mémoire persistante

Salut à tous, futurs dompteurs d’agents ! Emma ici, de retour sur agent101.net, et aujourd’hui nous allons aborder quelque chose qui me trotte dans la tête depuis des semaines : faire en sorte que votre agent IA se rappelle réellement des choses. Pas seulement pour une interaction unique, mais entre les sessions, même lorsque vous éteignez votre script et y revenez plus tard. C’est la différence entre un chatbot intelligent et un véritable assistant numérique, n’est-ce pas ?

Pendant un certain temps, je ne faisais que jouer avec des scripts simples et ponctuels. Mes petits agents Python faisaient leur travail – extraire des données, résumer un article – puis pouf ! Toute leur « connaissance » sur nos discussions ou tâches précédentes était envolée. On avait l’impression de parler à quelqu’un ayant de graves problèmes de mémoire à court terme, ce qui, bien que parfois amusant, n’est pas vraiment productif pour construire quelque chose d’utile.

Je me souviens d’avoir essayé de construire un assistant de recherche personnel. Mon objectif était simple : lui fournir des articles, lui poser des questions et lui faire constituer une base de connaissances sur un sujet spécifique. Les premières tentatives étaient… frustrantes. Je lui demandais « les dernières tendances en matière d’informatique quantique », et il me donnait un excellent résumé. Puis, cinq minutes plus tard, je demandais « et quelles sont les implications éthiques ? » et il agissait comme si nous n’avions jamais discuté d’informatique quantique. Je devais en gros le rééduquer à chaque fois. Parlez d’inefficacité !

C’est là que j’ai réalisé : pour qu’un agent IA soit vraiment un agent, il a besoin d’une mémoire. Pas juste un bloc-notes temporaire, mais un moyen persistant de stocker et de récupérer des informations. Et pour nous, les débutants, le monde des bases de données et des systèmes de génération augmentée de récupération (RAG) peut sembler un peu écrasant. Mais devinez quoi ? Ce n’est pas nécessaire. Nous pouvons commencer simplement, et c’est exactement ce que nous allons faire aujourd’hui.

Pourquoi la Mémoire Persistante est Importante pour Votre Agent IA

Pensez-y de cette façon : embaucheriez-vous un assistant humain qui oublierait tout ce que vous lui avez dit dès qu’il sortirait par la porte ? Probablement pas. La valeur d’un assistant, humain ou IA, réside souvent dans sa capacité à accumuler des connaissances sur vous, vos préférences, vos projets et vos interactions passées. Cette connaissance accumulée leur permet de :

• Fournir des réponses contextuellement pertinentes : Fini d’expliquer la même chose plusieurs fois.
• Réaliser des tâches en plusieurs étapes : Ils peuvent se souvenir des étapes précédentes et s’appuyer sur celles-ci.
• Apprendre et s’adapter au fil du temps : Leur « compréhension » de vos besoins grandit.
• Offrir une expérience personnalisée : Ils se souviennent de vos préférences, du nom de votre animal de compagnie, de votre café préféré – d’accord, peut-être pas encore le café, mais vous voyez l’idée !

Pour nous, qui commençons, la mémoire persistante est le lien entre un script sympathique et un véritable compagnon IA utile. C’est la différence entre un outil à usage unique et quelque chose qui semble vraiment travailler *avec* vous.

Le Chemin Convivial pour les Débutants : Fichiers Texte et JSON

D’accord, donc « mémoire persistante » sonne bien, mais pour notre première incursion, nous n’avons pas besoin de faire tourner un serveur PostgreSQL ou de lutter avec des bases de données vectorielles (pas encore !). Nous pouvons commencer par quelque chose de merveilleusement simple et étonnamment efficace : de bons vieux fichiers texte, en particulier des fichiers JSON.

Pourquoi JSON ? Parce que c’est structuré ! Cela nous permet de stocker des données au format clé-valeur, idéal pour organiser les informations que notre agent doit se rappeler. C’est également lisible par un humain, ce qui est un énorme avantage lorsque vous déboguez ou que vous essayez juste de comprendre ce que votre agent a stocké.

Imaginez que votre agent a un fichier « cerveau ». Chaque fois qu’il apprend quelque chose d’important, il l’écrit dans ce fichier. Chaque fois qu’il doit se rappeler quelque chose, il lit ce fichier. Simple, non ?

Exemple 1 : Se Souvenir des Préférences de l’Utilisateur

Disons que vous construisez un agent simple pour résumer du contenu. Vous voulez qu’il se souvienne de la longueur de résumé préférée de l’utilisateur (court, moyen, long) et de ses sujets favoris. Sans mémoire persistante, vous devriez lui demander à chaque fois. Avec un fichier JSON, vous demandez une fois, et votre agent se souvient.

Tout d’abord, pensons à la structure. Un fichier JSON simple pourrait ressembler à ceci :

{
 "user_preferences": {
 "summary_length": "medium",
 "favorite_topics": ["éthique de l'IA", "biotechnologie", "exploration spatiale"],
 "last_seen": "2026-03-26T10:30:00"
 },
 "conversation_history": []
}

Maintenant, comment faire interagir notre agent Python avec cela ?

Nous aurons besoin de fonctions pour charger et sauvegarder la mémoire. Voici une configuration de base :

import json
import os
from datetime import datetime

MEMORY_FILE = "agent_memory.json"

def load_memory():
 if os.path.exists(MEMORY_FILE):
 with open(MEMORY_FILE, 'r') as f:
 return json.load(f)
 return {
 "user_preferences": {
 "summary_length": "medium",
 "favorite_topics": [],
 "last_seen": None
 },
 "conversation_history": []
 }

def save_memory(memory):
 with open(MEMORY_FILE, 'w') as f:
 json.dump(memory, f, indent=4)

def update_user_preference(key, value):
 memory = load_memory()
 memory["user_preferences"][key] = value
 memory["user_preferences"]["last_seen"] = datetime.now().isoformat()
 save_memory(memory)
 print(f"Préférence mise à jour : {key} à {value}")

def get_user_preference(key):
 memory = load_memory()
 return memory["user_preferences"].get(key)

# --- Exemple d'Interaction avec l'Agent ---

if __name__ == "__main__":
 print("Bienvenue de nouveau à votre agent !")

 # Charger la mémoire existante ou en initialiser une nouvelle
 current_memory = load_memory()
 print(f"Votre longueur de résumé préférée est : {get_user_preference('summary_length')}")
 print(f"Vos sujets favoris sont : {get_user_preference('favorite_topics')}")

 # Simuler l'utilisateur définissant une préférence
 user_input = input("Souhaitez-vous des résumés 'courts', 'moyens' ou 'longs' ? (Tapez pour changer ou appuyez sur Entrée pour garder) : ").strip().lower()
 if user_input in ["court", "moyen", "long"]:
 update_user_preference("summary_length", user_input)
 print(f"D'accord, je me souviendrai que vous préférez des résumés {user_input}.")
 else:
 print("Conservation de la préférence actuelle.")

 # Simuler l'agent utilisant la mémoire
 preferred_length = get_user_preference("summary_length")
 print(f"Génération d'un résumé {preferred_length} pour votre prochaine tâche...")

 # Ajoutons un nouveau sujet favori
 new_topic = input("Des nouveaux sujets favoris à ajouter ? ").strip()
 if new_topic:
 topics = get_user_preference('favorite_topics')
 if new_topic not in topics:
 topics.append(new_topic)
 update_user_preference('favorite_topics', topics)
 print(f"Ajout de '{new_topic}' à vos sujets favoris.")
 else:
 print(f"'{new_topic}' est déjà dans vos favoris.")

 print(f"\nAprès cette session, votre mémoire ressemble à ceci :")
 print(json.dumps(load_memory(), indent=4))

Que se passe-t-il ici ?

• `load_memory()` vérifie si `agent_memory.json` existe. Si c’est le cas, il le lit. Sinon, il crée une structure de base.
• `save_memory()` prend notre dictionnaire Python et l’écrit dans le fichier JSON.
• `update_user_preference()` et `get_user_preference()` sont des fonctions utilitaires pour faciliter l’interaction avec des parties spécifiques de la mémoire.
• La partie principale du script (`if __name__ == “__main__”:`) simule un utilisateur interagissant avec l’agent, définissant des préférences, puis l’agent utilisant ces préférences.

Essayez d’exécuter ce script plusieurs fois. Vous verrez que vos préférences persistent même après avoir fermé et rouvert le script ! C’est la magie de la mémoire persistante, même dans sa forme la plus simple.

Exemple 2 : Se Souvenir de l’Histoire des Conversations

Au-delà des préférences, une partie cruciale de la mémoire d’un agent est de se souvenir de ce qui vient d’être dit. Cela est particulièrement important pour les conversations ou les tâches multi-tours. Bien que les LLM aient une « fenêtre de contexte », ce contexte est généralement effacé après chaque appel d’API ou session. Nous voulons l’étendre.

Modifions notre `agent_memory.json` pour inclure une liste `conversation_history`. Chaque entrée dans cette liste pourrait être un dictionnaire contenant le locuteur (utilisateur/agent) et le message.

Structure mise à jour de `agent_memory.json` :

{
 "user_preferences": {
 "summary_length": "medium",
 "favorite_topics": ["éthique de l'IA", "biotechnologie", "exploration spatiale"],
 "last_seen": "2026-03-26T10:30:00"
 },
 "conversation_history": [
 {"role": "user", "message": "Salut, quoi de neuf ?"},
 {"role": "agent", "message": "Pas grand-chose, j'attends juste vos instructions !"}
 ]
}

Ajoutons maintenant des fonctions pour gérer cette histoire :

import json
import os
from datetime import datetime

MEMORY_FILE = "agent_memory.json"

# (Inclure les fonctions load_memory et save_memory de l'exemple précédent)

def load_memory():
 if os.path.exists(MEMORY_FILE):
 with open(MEMORY_FILE, 'r') as f:
 return json.load(f)
 return {
 "user_preferences": {
 "summary_length": "medium",
 "favorite_topics": [],
 "last_seen": None
 },
 "conversation_history": []
 }

def save_memory(memory):
 with open(MEMORY_FILE, 'w') as f:
 json.dump(memory, f, indent=4)

def add_to_history(role, message):
 memory = load_memory()
 memory["conversation_history"].append({"role": role, "message": message, "timestamp": datetime.now().isoformat()})
 # Optionnel : Garder l'historique à une taille gérable, disons les 10 dernières interactions
 if len(memory["conversation_history"]) > 10:
 memory["conversation_history"] = memory["conversation_history"][-10:]
 save_memory(memory)

def get_conversation_history():
 memory = load_memory()
 return memory["conversation_history"]

# --- Exemple d'interaction avec l'agent et l'historique ---

if __name__ == "__main__":
 print("Bienvenue de nouveau ! Voici notre conversation récente :")
 for entry in get_conversation_history():
 print(f"{entry['role'].capitalize()}: {entry['message']}")

 while True:
 user_message = input("Vous: ")
 if user_message.lower() == "exit":
 break
 
 add_to_history("user", user_message)
 print(f"Agent: (Réfléchissant à : '{user_message}' et à l'historique précédent...)")
 
 # Simuler la réponse de l'agent (dans un véritable agent, cela impliquerait un appel LLM)
 agent_response = f"D'accord, vous avez dit '{user_message}'. Je vais m'en souvenir."
 add_to_history("agent", agent_response)
 print(f"Agent: {agent_response}")

 print("\nConversation terminée. Votre historique de conversation a été enregistré.")
 print(json.dumps(load_memory(), indent=4))

Dans cet exemple, chaque message de l’utilisateur et chaque réponse simulée de l’agent sont ajoutés à la liste `conversation_history` dans notre fichier JSON. Lorsque le script démarre, il charge cet historique, offrant à l’agent une certaine “mémoire” des interactions précédentes. J’ai ajouté une petite ligne pour tronquer l’historique aux 10 dernières entrées – c’est une façon simple d’éviter que votre fichier mémoire ne grossisse indéfiniment, ce qui peut être un problème avec des conversations très longues.

Considérations et Prochaines Étapes

Bien que les fichiers JSON soient fantastiques pour commencer, ils ont des limites :

• Scalabilité : Pour de très grandes quantités de données, lire et écrire le fichier entier de manière répétée peut devenir lent.
• Concurrence : Si plusieurs parties de votre agent (ou plusieurs agents) tentent d’écrire dans le même fichier en même temps, vous pouvez rencontrer des problèmes.
• Requêtes Complexes : Il est difficile de poser des questions comme “trouver toutes les conversations où l’utilisateur a mentionné ‘informatique quantique’ ET ‘implications éthiques’.” Vous devez charger le fichier entier et rechercher manuellement.

Mais pour un débutant, et pour de nombreux projets personnels, ces limitations sont parfaitement acceptables. Vous apprenez le concept de base de la mémoire persistante sans la complexité supplémentaire d’une base de données.

Une fois que vous êtes à l’aise avec les fichiers JSON, voici quelques prochaines étapes naturelles :

1. SQLite : C’est une base de données relationnelle basée sur des fichiers qui est super facile à intégrer avec Python. Elle résout les problèmes de scalabilité et de requêtes des fichiers JSON sans nécessiter de serveur séparé. C’est souvent la prochaine étape logique pour de nombreux projets.
2. Bases de Données Vectorielles (ex. : Chroma, FAISS) : C’est là que les choses deviennent vraiment intéressantes pour les agents IA ! Les bases de données vectorielles stockent des informations sous forme d’embeddings numériques, permettant à votre agent d’effectuer des recherches sémantiques (ex. : “trouver des informations liées à ce concept,” même si les mots-clés exacts ne sont pas présents). C’est la base de nombreux systèmes RAG avancés.
3. Structures de Mémoire Plus Sophistiquées : Au lieu de conversations brutes, vous pourriez essayer des points clés, extraire des entités, ou même construire un “graphe de connaissances” dans votre mémoire.

Mes Conseils pour Vous

La mémoire persistante n’est pas seulement une fonctionnalité avancée ; c’est un besoin fondamental pour construire des agents IA qui semblent réellement utiles et intelligents. Commencer par de simples fichiers JSON est un moyen incroyablement pratique de saisir le concept de base sans se laisser entraîner dans la complexité.

Voici ce que je veux que vous reteniez aujourd’hui :

• Commencez simple : Ne vous sentez pas obligé d’utiliser la technologie la plus avancée dès le départ. Les fichiers JSON sont vos amis pour la mémoire persistante des débutants.
• La structure est essentielle : Même dans un fichier JSON, pensez à la façon dont vous souhaitez organiser la mémoire de votre agent (préférences, historique, faits appris, etc.).
• Pratiquez le chargement et l’enregistrement : La boucle fondamentale de `load_memory()`, modifier `memory`, `save_memory()` est ce que vous utiliserez constamment.
• Itérez et étendez : Une fois que vous êtes à l’aise avec JSON, mettez-vous au défi de passer à SQLite, puis explorez peut-être des bases de données vectorielles. Chaque étape s’appuie sur la précédente.

Je me souviens qu’une fois que j’ai fait en sorte que mon agent simple “se souvienne” de ma longueur de résumé préférée à travers les sessions, cela a semblé être une petite avancée. Ce n’était pas juste de l’exécution de code ; cela commençait à ressembler à un petit cerveau numérique à lui seul. Essayez, vous serez étonné de la capacité de vos agents à s’améliorer !

Bonne programmation, et continuons à construire ces agents plus intelligents !

🕒 Published: March 26, 2026