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

Salut à tous, futurs agents ! Emma ici, de retour sur agent101.net, et aujourd’hui, nous allons nous plonger dans un sujet qui me taraude depuis des semaines : amener votre agent IA à vraiment se souvenir des choses. Pas juste pour une seule interaction, mais à travers les sessions, même lorsque vous fermez votre script et y revenez plus tard. C’est la différence entre un chatbot astucieux et un véritable assistant numérique, non ?

Pendant un certain temps, je jouais simplement avec des scripts simples et ponctuels. Mes petits agents Python faisaient leur travail – récupéraient des données, résumaient un article – et ensuite, pouf ! Tout leur “savoir” sur nos conversations ou tâches précédentes avait disparu. On avait l’impression de parler à quelqu’un ayant de graves pertes de mémoire à court terme, ce qui, bien que parfois amusant, n’est pas vraiment productif pour construire quoi que ce soit d’utile.

Je me souviens avoir essayé de créer un assistant de recherche personnel. Mon objectif était simple : lui fournir des articles, lui poser des questions et lui faire construire 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 les implications éthiques ?” et il faisait comme si nous n’avions jamais discuté d’informatique quantique. Je le rééduquais pratiquement à chaque fois. Parlez de quelque chose d’inefficace !

C’est à ce moment-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 complexes 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 manière : embaucheriez-vous un assistant humain qui oublie tout ce que vous lui dites dès qu’il passe la porte ? Probablement pas. La valeur d’un assistant, qu’il soit humain ou IA, vient souvent de 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 : Plus besoin d’expliquer la même chose plusieurs fois.
• Effectuer des tâches en plusieurs étapes : Ils peuvent se souvenir des étapes précédentes et les enrichir.
• 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 avez compris l’idée !

Pour nous qui commençons, la mémoire persistante est le pont entre un script sympa et un véritable compagnon IA utile. C’est la différence entre un outil à usage unique et quelque chose qui fonctionne réellement *avec* vous.

Le Chemin Pour Débutants : Fichiers Textes et JSON

D’accord, donc “mémoire persistante” semble sophistiqué, mais pour notre première approche, nous n’avons pas besoin de mettre en place un serveur PostgreSQL ou de nous battre avec des bases de données vectorielles (pas encore !). Nous pouvons commencer avec quelque chose de merveilleusement simple et étonnamment efficace : de bons vieux fichiers texte, spécifiquement des fichiers JSON.

Pourquoi JSON ? Parce que c’est structuré ! Cela nous permet de stocker des données sous forme de paires clé-valeur, ce qui est parfait pour organiser les informations que notre agent doit retenir. C’est aussi lisible par l’homme, ce qui est un énorme avantage lorsque vous déboguez ou que vous essayez simplement de comprendre ce que votre agent a enregistré.

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 souvenir de quelque chose, il lit ce fichier. Simple, n’est-ce pas ?

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

Disons que vous construisez un agent de résumé de contenu simple. 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 devrez lui demander à chaque fois. Avec un fichier JSON, vous demandez une fois, et votre agent se souvient.

Tout d’abord, réfléchissons à la structure. Un simple fichier JSON 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 la mémoire 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 chez votre agent !")

 # Charger la mémoire existante ou 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 un utilisateur définissant une préférence
 user_input = input("Voulez-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 vais me souvenir que vous préférez des résumés {user_input}.")
 else:
 print("Préférence actuelle conservée.")

 # 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 préféré
 new_topic = input("Des nouveaux sujets préférés à 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 à :")
 print(json.dumps(load_memory(), indent=4))

Qu’est-ce qui se passe ici ?

• `load_memory()` vérifie si `agent_memory.json` existe. Si oui, 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 auxiliaires 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 de faire tourner 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 de la Conversation

Au-delà des préférences, un aspect crucial 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 en plusieurs tours. Alors que les LLM ont une “fenêtre de contexte,” ce contexte est généralement effacé après chaque appel d’API ou session. Nous voulons étendre cela.

Modifions notre `agent_memory.json` pour inclure une liste `conversation_history`. Chaque entrée dans cette liste pourrait être un dictionnaire contenant le rôle (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 !"}
 ]
}

Maintenant, ajoutons 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 historique ---

if __name__ == "__main__":
 print("Content de te revoir ! Voici notre discussion 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("\nDiscussion terminée. Votre historique de conversation a été sauvegardé.")
 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 manière simple d’éviter que votre fichier de mémoire ne grandisse indéfiniment, ce qui peut être un problème avec les conversations très longues.

Considérations et prochaines étapes

Bien que les fichiers JSON soient fantastiques pour commencer, ils présentent des limitations :

• Scalabilité : Pour de très grandes quantités de données, lire et écrire tout le fichier plusieurs fois peut devenir lent.
• Concurrence : Si plusieurs parties de votre agent (ou plusieurs agents) essaient 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 « trouvez toutes les conversations où l’utilisateur a mentionné ‘informatique quantique’ ET ‘implications éthiques’ ». Vous devriez charger le fichier entier et rechercher manuellement.

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

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

1. SQLite : Il s’agit d’une base de données relationnelle basée sur un fichier, très facile à intégrer avec Python. Elle résout les problèmes de scalabilité et de requête 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 (par exemple, Chroma, FAISS) : C’est ici 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 de réaliser des recherches sémantiques (par exemple, « trouvez 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 avancés de RAG.
3. Structures de mémoire plus sophistiquées : Au lieu de simplement conserver des conversations brutes, vous pourriez essayer de noter des points clés, d’extraire des entités, ou même de 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 une exigence fondamentale pour construire des agents IA qui semblent réellement utiles et intelligents. Commencer avec de simples fichiers JSON est une manière incroyablement pratique de saisir le concept fondamental sans se laisser submerger par 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 une mémoire persistante pour débutants.
• La structure est essentielle : Même dans un fichier JSON, pensez à la manière dont vous souhaitez organiser la mémoire de votre agent (préférences, historique, faits appris, etc.).
• Pratiquez le chargement et la sauvegarde : La boucle principale de `load_memory()`, modifiez `memory`, `save_memory()` est ce que vous utiliserez constamment.
• Répétez et élargissez : Une fois que vous êtes à l’aise avec JSON, mettez-vous au défi de passer à SQLite, puis explorez peut-être les bases de données vectorielles. Chaque étape s’appuie sur la précédente.

Je me souviens qu’une fois que j’ai réussi à faire en sorte que mon agent simple « se souvienne » de ma longueur de résumé préférée d’une session à l’autre, cela ressemblait à une petite percée. Ce n’était pas juste exécuter du code ; cela commençait à donner l’impression d’avoir un petit cerveau numérique à lui tout seul. Essayez – vous serez surpris de voir à quel point vos agents deviennent plus capables !

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

🕒 Published: March 26, 2026