Système de mémoire pour agents AI Donne aux agents AI la continuité et le contexte nécessaires entre les sessions

Les agents AI oublient tout entre les sessions. Chaque conversation repart de zéro :

• ❌ Répètent les mêmes erreurs
• ❌ Ignorent les décisions passées
• ❌ Manquent de contexte projet
• ❌ Ne comprennent pas les patterns établis
• ❌ Oublient vos préférences

Résultat : Vous perdez du temps à réexpliquer, l'AI suggère des solutions déjà rejetées, et la productivité chute.

AI Memory System = Fichiers Markdown structurés que l'AI lit au démarrage de chaque session.

• Timeline chronologique inversée (récent → ancien)
• Décisions documentées avec leur contexte
• Idées rejetées + raisons (pour ne pas répéter)
• Patterns et préférences utilisateur
• Leçons apprises

• Bootstrap automatique depuis l'historique Git
• Extraction des événements marquants
• Process de validation humaine intégré
• Parfait pour projets existants

• Mémoires spécialisées par domaine (Backend, Frontend, DevOps, etc.)
• Expertise ciblée par contexte
• Cross-references entre domaines
• Architecture modulaire et évolutive

# 1. Copier le template
cp ai-memory-system/MEMORY_TEMPLATE.md docs/AI_MEMORY.md

# 2. Remplir avec votre historique
# Éditez docs/AI_MEMORY.md

# 3. Configurer les instructions AI
cp .claude/AI_MEMORY_INSTRUCTIONS.md .claude/

# 4. Démarrer votre session AI
# L'AI lira automatiquement la mémoire

# 1. Suivre le guide d'import Git
cat ai-memory-system/GIT_HISTORY_IMPORT.md

# 2. Lancer l'analyse Git (commandes dans le guide)
git log --oneline --decorate --all -100

# 3. Demander à l'AI de générer le draft
# (Voir prompt complet dans GIT_HISTORY_IMPORT.md)

# 4. Valider et finaliser
# L'AI créera docs/AI_MEMORY.md

# 1. Créer la structure
mkdir -p docs/memory

# 2. Copier les exemples
cp ai-memory-system/examples/*.memory.example.md docs/memory/

# 3. Adapter à votre projet
# Éditez chaque fichier *.memory.md

# 4. Configurer les agents
# Voir ai-memory-system/MULTI_AGENT_MEMORY.md

ai-memory-system/
├── README.md                      # Ce fichier
├── MEMORY_TEMPLATE.md             # Template de mémoire (changelog style)
├── GIT_HISTORY_IMPORT.md          # Guide d'import depuis Git
├── MULTI_AGENT_MEMORY.md          # Système multi-agents (révolutionnaire!)
│
├── examples/                      # Exemples concrets
│   ├── backend.memory.example.md  # Exemple mémoire Backend
│   └── frontend.memory.example.md # Exemple mémoire Frontend
│
└── docs/                          # Documentation projet
    ├── AI_MEMORY.md               # Mémoire principale (à créer)
    ├── AI_MEMORY_QUICK_REF.md     # Résumé 30 secondes
    └── STATUS.md                  # État actuel du projet

## 📅 Timeline

### [2025-12-05] — Événement Récent
**Contexte**: Pourquoi ce changement
**Actions**: Ce qui a été fait
**Résultat**: Impact observable
**Décisions**: ✅ Approuvé / ❌ Rejeté

### [2025-11-20] — Événement Plus Ancien
...

Avantage : L'AI voit d'abord le contexte récent (le plus pertinent)

## 🚫 Idées Rejetées

### Ne PAS utiliser MongoDB
**Raison**: Testé en Oct 2024, relations complexes inadaptées
**Alternative**: PostgreSQL choisi
**Réévaluer**: Si besoins changent

Avantage : L'AI ne suggère pas des solutions déjà testées et rejetées

## 🎯 Préférences

### ✅ À FAIRE
- Utiliser TypeScript strict mode
- Tests obligatoires avant merge
- Conventional Commits

### ❌ NE PAS FAIRE
- Pusher directement sur main
- Utiliser console.log en prod
- Skip les migrations

Avantage : L'AI respecte vos standards dès le début

docs/memory/
├── AI_MEMORY.md              # Index & coordination
├── backend.memory.md         # Expert Backend
├── frontend.memory.md        # Expert Frontend
├── devops.memory.md          # Expert DevOps
└── security.memory.md        # Expert Sécurité

Avantages :

• Expertise ciblée par domaine
• Pas de surcharge cognitive
• Collaboration entre agents facilitée
• Architecture modulaire (ajoutez des domaines facilement)

Avant : 2 semaines de ramping, lecture de docs éparpillées Avec AI Memory :

# Le dev pose des questions à l'AI
"Comment fonctionne l'authentification ici ?"
"Pourquoi avez-vous choisi PostgreSQL ?"
"Quels sont les anti-patterns à éviter ?"

# L'AI répond avec le contexte exact du projet
# (Pas de réponse générique, mais votre historique)

Avant :

Session 1: "Implémente l'auth avec JWT"
Session 2 (lendemain): AI ne se souvient de rien
Vous: "Rappelle-toi, on utilise JWT..."

Avec AI Memory :

Session 1: "Implémente l'auth avec JWT" → MAJ de AI_MEMORY.md
Session 2 (lendemain): AI lit la mémoire au démarrage
AI: "Je vois qu'on utilise JWT (15min access + 7j refresh), je continue sur cette base"

Avant :

AI: "Je suggère d'utiliser MongoDB"
Vous: "Non, on a déjà testé, ça marche pas pour nos relations complexes"
(Une semaine plus tard)
AI: "Et si on utilisait MongoDB ?"
Vous: 😤

Avec AI Memory :

## Idées Rejetées
### Ne PAS utiliser MongoDB
**Raison**: Testé Oct 2024, relations complexes inadaptées

AI: (lit la mémoire) "Je vois que MongoDB a été rejeté, je propose PostgreSQL"
Vous: 🎉

Scénario : Ajouter un nouvel endpoint API

[Agent Backend]
- Lit: AI_MEMORY.md + backend.memory.md + database.memory.md
- Implémente: POST /api/users/export
- Met à jour: backend.memory.md avec cross-ref vers frontend

[Agent Frontend]
- Lit: AI_MEMORY.md + frontend.memory.md + backend.memory.md
- Voit: Nouvelle note dans backend.memory.md
- Implémente: Bouton "Export" qui call le nouvel endpoint

Résultat : Handoff fluide entre agents, comme une vraie équipe !

• ⬆️ 70% moins de temps à réexpliquer le contexte
• ⬆️ 50% moins d'itérations (bonnes décisions dès le début)
• ⬆️ 80% moins d'erreurs répétées

• ✅ Cohérence des patterns dans tout le codebase
• ✅ Décisions documentées et traçables
• ✅ Onboarding accéléré (humains et AI)

• 📈 Mémoire modulaire (multi-agent)
• 📈 Évolution organique (ajout de domaines facile)
• 📈 Pas de limite de taille (fichiers séparés)

# .claude/AI_MEMORY_INSTRUCTIONS.md

Au démarrage de chaque session:

1. Lis docs/AI_MEMORY.md (mémoire principale)
2. Lis docs/STATUS.md (état actuel)
3. Lis docs/AI_MEMORY_QUICK_REF.md (résumé)

Avant toute action:
- Vérifie les préférences utilisateur
- Respecte les anti-patterns documentés
- Check les décisions passées

Après chaque tâche majeure:
- Mets à jour AI_MEMORY.md (timeline)
- Documente les décisions prises
- Ajoute les leçons apprises

Ajoutez dans vos instructions:

Read docs/AI_MEMORY.md for project context, decisions, and patterns.

import anthropic

# Charger la mémoire
with open('docs/AI_MEMORY.md') as f:
    memory = f.read()

# Injecter dans le system prompt
client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    system=f"{memory}\n\n{your_instructions}",
    messages=[...]
)

# Après chaque feature majeure
git commit -m "feat: implement user export"
# Puis
# Mettre à jour docs/AI_MEMORY.md avec l'événement

• ✅ "Rejeté MongoDB: relations complexes inadaptées"
• ❌ "On a essayé MongoDB mais ça marchait pas terrible et puis finalement on a préféré autre chose"

• Format ISO: [2025-12-05]
• Permet de contextualiser les décisions

### [2025-12-01] — Nouveau système d'auth
**Cross-ref**:
- Backend: backend.memory.md#jwt-implementation
- Frontend: frontend.memory.md#auth-flow
- Security: security.memory.md#token-security

• Archiver les événements très anciens
• Mettre à jour les métriques
• Valider que les patterns sont toujours d'actualité

• Memory Template (changelog style)
• Git History Import
• Documentation complète

• Concept Multi-Agent Memory
• Exemples Backend/Frontend
• Templates pour autres domaines
• Outils de validation cross-refs

• CLI pour générer mémoires
• GitHub Action pour auto-update
• Détection automatique de domaines
• Suggestions de cross-refs par AI
• Métriques et analytics

Ce projet est open source et accueille les contributions !

1. Fork le repo
2. Créez une branche: git checkout -b feature/amazing-feature
3. Committez: git commit -m 'feat: add amazing feature'
4. Pushez: git push origin feature/amazing-feature
5. Ouvrez une Pull Request

• Templates pour nouveaux domaines (Testing, Design, etc.)
• Exemples pour d'autres stacks (Python, Go, Rust, etc.)
• Intégrations avec d'autres AI tools
• Outils CLI pour automatisation
• Traductions (EN, ES, etc.)

• MEMORY_TEMPLATE.md — Template de base
• GIT_HISTORY_IMPORT.md — Import depuis Git
• MULTI_AGENT_MEMORY.md — Système multi-agents

• backend.memory.example.md
• frontend.memory.example.md

• GitHub Issues: [Report bugs, suggest features]
• GitHub Discussions: [Ask questions, share ideas]

MIT License — Utilisez librement, modifiez, partagez !

Voir LICENSE pour détails.

Créé par : CoRhino + collaborators Date de création : 2025-12-05

# Clonez le repo
git clone https://github.com/your-username/ai-memory-system.git

# Nouveau projet
cp ai-memory-system/MEMORY_TEMPLATE.md docs/AI_MEMORY.md

# OU projet existant
cat ai-memory-system/GIT_HISTORY_IMPORT.md
# Suivez les instructions

Questions ? Ouvrez une issue sur GitHub Feedback ? Les retours sont toujours utiles