Bienvenue dans ce tutoriel dédié aux débutants ! Aujourd'hui, vous allez apprendre à construire un système de mémoire intelligent pour un agent conversationnel. Ce concept, souvent réservé aux développeurs avancés, devient enfin accessible grâce à HolySheep AI.

📚 Comprendre les Trois Types de Mémoire

Avant de coder, comprenons pourquoi un agent IA a besoin de mémoire. Imaginez que vous parlez à un assistant qui ne se souvient de rien d'une conversation à l'autre — frustrant, n'est-ce pas ?

C'est exactement ce que nous allons construire ensemble. Pas de panique si ces termes vous semblent nouveaux — nous partons de zéro.

🔧 Préparation de l'Environnement

Étape 1 : Créer un Compte HolySheep

Pour commencer, vous aurez besoin d'une clé API. HolySheep AI offre des crédits gratuits pour les nouveaux utilisateurs, avec des tarifs imbattables : DeepSeek V3.2 à seulement $0.42/MTok et une latence inférieure à 50ms. Les paiements sont acceptés via WeChat et Alipay.

Après inscription, récupérez votre clé API dans votre tableau de bord.

Étape 2 : Installer Python

Si vous n'avez pas Python installé, téléchargez-le depuis python.org. Lors de l'installation, cochez "Add Python to PATH".

Étape 3 : Installer les Bibliothèques

Ouvrez votre terminal (ou invite de commandes) et tapez :

pip install requests numpy scikit-learn

Ces bibliothèques nous permettront de communiquer avec l'API et de traiter les données.

🏗️ Architecture du Système de Mémoire

Notre système fonctionne en trois couches complémentaires :

💻 Le Code Complet — Pas à Pas

Partie 1 : Configuration de la Connexion API

import requests
import json
import numpy as np
from datetime import datetime


Configuration HolySheep API

BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"

def envoyer_message(messages):
    """Envoie une requête à l'API HolySheep"""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "gpt-4.1",
        "messages": messages,
        "temperature": 0.7
    }
    
    reponse = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=payload
    )
    
    return reponse.json()

Note : Le modèle gpt-4.1 coûte seulement $8/MTok sur HolySheep, bien moins cher que les alternatives.

Partie 2 : Classe de Mémoire Court Terme

class MemoireCourtTerme:
    """Gère les derniers échanges de la conversation"""
    
    def __init__(self, capacite=10):
        self.capacite = capacite
        self.messages = []
    
    def ajouter(self, role, contenu):
        """Ajoute un message à la mémoire"""
        self.messages.append({
            "role": role,
            "content": contenu,
            "timestamp": datetime.now().isoformat()
        })
        
        # Supprime les messages trop anciens
        if len(self.messages) > self.capacite:
            self.messages.pop(0)
    
    def obtenir_historique(self):
        """Retourne l'historique formaté pour l'API"""
        return [
            {"role": msg["role"], "content": msg["content"]} 
            for msg in self.messages
        ]


Démonstration

memoire = MemoireCourtTerme(capacite=5)
memoire.ajouter("user", "Je suis développeur débutant")
memoire.ajouter("assistant", "Bienvenue ! Je vais vous aider.")
print("Historique:", memoire.obtenir_historique())

Ce code crée un espace mémoire qui garde les 5 derniers échanges. Quand un 6ème arrive, le plus ancien est automatiquement supprimé — comme notre mémoire humaine !

Partie 3 : Classe de Mémoire Long Terme

import json
from pathlib import Path

class MemoireLongTerme:
    """Sauvegarde les informations importantes entre les sessions"""
    
    def __init__(self, fichier="memoire_long terme.json"):
        self.fichier = fichier
        self.memoire = self.charger()
    
    def charger(self):
        """Charge la mémoire depuis le fichier"""
        if Path(self.fichier).exists():
            with open(self.fichier, "r", encoding="utf-8") as f:
                return json.load(f)
        return []
    
    def sauvegarder(self):
        """Sauvegarde la mémoire dans le fichier"""
        with open(self.fichier, "w", encoding="utf-8") as f:
            json.dump(self.memoire, f, ensure_ascii=False, indent=2)
    
    def ajouter_souvenir(self, sujet, contenu, importance=5):
        """Ajoute un nouveau souvenir"""
        souvenir = {
            "id": len(self.memoire) + 1,
            "sujet": sujet,
            "contenu": contenu,
            "importance": min(10, max(1, importance)),
            "date_creation": datetime.now().isoformat()
        }
        self.memoire.append(souvenir)
        self.sauvegarder()
        return souvenir
    
    def chercher(self, terme):
        """Recherche simple par mot-clé"""
        resultats = []
        for souvenir in self.memoire:
            if terme.lower() in souvenir["contenu"].lower():
                resultats.append(souvenir)
        return resultats


Exemple d'utilisation

memoire_lt = MemoireLongTerme()
memoire_lt.ajouter_souvenir(
    sujet="Préférences utilisateur",
    contenu="L'utilisateur préfère les explications détaillées",
    importance=8
)
memoire_lt.ajouter_souvenir(
    sujet="Projet en cours",
    contenu="Construction d'un agent IA avec système de mémoire",
    importance=9
)


Rechercher des souvenirs

resultats = memoire_lt.chercher("préférences")
print(f"Résultats trouvés: {len(resultats)}")

Grâce à HolySheep AI et ses tarifs avantageux, vous pouvez traiter des milliers de souvenirs pour seulement quelques centimes.

Partie 4 : Système de Recherche Vectorielle

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

class RechercheVectorielle:
    """Permet de trouver les souvenirs les plus pertinents"""
    
    def __init__(self):
        self.vectorizer = TfidfVectorizer()
        self.souvenirs = []
        self.matrice = None
    
    def indexer(self, souvenirs):
        """Crée l'index vectoriel des souvenirs"""
        self.souvenirs = souvenirs
        if not souvenirs:
            self.matrice = None
            return
        
        textes = [s["contenu"] for s in souvenirs]
        self.matrice = self.vectorizer.fit_transform(textes)
    
    def rechercher(self, requete, top_k=3):
        """Trouve les k souvenirs les plus similaires"""
        if self.matrice is None or len(self.souvenirs) == 0:
            return []
        
        vecteur_requete = self.vectorizer.transform([requete])
        similarites = cosine_similarity(vecteur_requete, self.matrice)[0]
        
        # Associe scores et souvenirs
        couples = list(zip(similarites, self.souvenirs))
        couples_tries = sorted(couples, key=lambda x: x[0], reverse=True)
        
        return couples_tries[:top_k]


Démonstration complète

recherche = RechercheVectorielle()
recherche.indexer(memoire_lt.memoire)

resultats = recherche.rechercher("informations sur l'utilisateur", top_k=2)
print("\n📋 Souvenirs les plus pertinents :")
for score, souvenir in resultats:
    print(f"  • [{score:.2f}] {souvenir['sujet']}: {souvenir['contenu']}")

Partie 5 : Intégration Complete — L'Agent IA avec Mémoire

class AgentIAAvecMemoire:
    """Agent conversationnel avec système de mémoire complet"""
    
    def __init__(self):
        self.memoire_court = MemoireCourtTerme(capacite=10)
        self.memoire_long = MemoireLongTerme()
        self.recherche = RechercheVectorielle()
        
        # Rafraîchir l'index de recherche
        self._actualiser_index()
    
    def _actualiser_index(self):
        """Met à jour l'index vectoriel"""
        self.recherche.indexer(self.memoire_long.memoire)
    
    def _construire_contexte(self, question):
        """Récupère les souvenirs pertinents et construit le contexte"""
        # Recherche dans la mémoire long terme
        souvenirs = self.recherche.rechercher(question, top_k=3)
        
        contexte = "INFORMATIONS PERTINENTES DE LA MÉMOIRE :\n"
        if souvenirs:
            for _, s in souvenirs:
                contexte += f"- {s['sujet']}: {s['contenu']}\n"
        else:
            contexte += "Aucun souvenir pertinent trouvé.\n"
        
        return contexte
    
    def _construire_prompt(self, question):
        """Construit le message complet pour l'API"""
        # Ajouter la question à la mémoire court terme
        self.memoire_court.ajouter("user", question)
        
        # Récupérer le contexte
        contexte = self._construire_contexte(question)
        
        # Construire le système
        system_prompt = f"""Tu es un assistant IA helpful avec une mémoire.
{contexte}
"""
        
        # Récupérer l'historique court terme
        messages = [{"role": "system", "content": system_prompt}]
        messages.extend(self.memoire_court.obtenir_historique())
        
        return messages
    
    def poser_question(self, question):
        """Envoie une question et retourne la réponse"""
        messages = self._construire_prompt(question)
        
        # Appeler l'API HolySheep
        reponse = envoyer_message(messages)
        
        if "error" in reponse:
            return f"Erreur: {reponse['error']}"
        
        texte_reponse = reponse["choices"][0]["message"]["content"]
        
        # Sauvegarder dans la mémoire long terme si important
        self.memoire_court.ajouter("assistant", texte_reponse)
        
        # Option : sauvegarder automatiquement les infos importantes
        if "se souviens" in question.lower() or "mémorise" in question.lower():
            self.memoire_long.ajouter_souvenir(
                sujet="Information demandée",
                contenu=question + " -> " + texte_reponse[:200],
                importance=7
            )
            self._actualiser_index()
        
        return texte_reponse


===== UTILISATION =====


print("=" * 50)
print("🎓 AGENT IA AVEC MÉMOIRE INTÉGRÉE")
print("=" * 50)

agent = AgentIAAvecMemoire()


Première interaction

print("\n🤖 Utilisateur: Qui suis-je?")
reponse1 = agent.poser_question("Qui suis-je?")
print(f"🤖 Assistant: {reponse1}")


L'agent mémorise une information

print("\n🤖 Utilisateur: Je m'appelle Pierre et j'aime la programmation Python")
agent.poser_question("Je m'appelle Pierre et j'aime la programmation Python")


On sauvegarde manuellement

agent.memoire_long.ajouter_souvenir(
    sujet="Nom de l'utilisateur",
    contenu="L'utilisateur s'appelle Pierre",
    importance=9
)
agent._actualiser_index()


Deuxième interaction — l'agent devrait se souvenir

print("\n🤖 Utilisateur: Comment m'appelles-tu?")
reponse2 = agent.poser_question("Comment m'appelles-tu?")
print(f"🤖 Assistant: {reponse2}")

📊 Schéma du Flux de Données

+------------------+      +---------------------+      +------------------+
|   Utilisateur    | ---> | Mémoire Court Terme | ---> |    HolySheep     |
|   (Question)     |      |   [10 derniers]     |      |   API (gpt-4.1)  |
+------------------+      +---------------------+      +------------------+
                                  |                            |
                                  v                            v
                         +---------------------+      +------------------+
                         | Mémoire Long Terme |<---- |    Réponse       |
                         |  [Fichier JSON]    |      |   de l'IA        |
                         +---------------------+      +------------------+
                                  |
                                  v
                         +---------------------+
                         | Recherche         |
                         | Vectorielle (TF-IDF)|
                         +---------------------+
                                  |
                                  v
                         +---------------------+
                         | Contexte pertinent |
                         | pour l'IA          |
                         +---------------------+

🧪 Test et Validation

Pour vérifier que votre système fonctionne correctement, lancez le script complet :

python agent_memoire.py

Vous devriez voir s'afficher :

🔄 Améliorations Possibles

Erreurs courantes et solutions

🎯 Résumé

Vous avez appris à construire un système de mémoire en trois couches pour votre agent IA :