From 0fad1d7249b0722de0e6e17a63cd3b94d0080cb1 Mon Sep 17 00:00:00 2001 From: Folzo Date: Wed, 8 Apr 2026 21:57:23 +0200 Subject: [PATCH] docs: add comprehensive memory solutions research - Research 8 different memory solutions (mem0, LangChain, LlamaIndex, etc.) - Document 5 levels of AI memory - Explain why mem0 was abandoned (5-10s latency) - Current state: manual snippets via OpenWebUI - Future technologies: MemGPT, memory-augmented LLMs, knowledge graphs - Recommendations for Effi short/mid/long term --- docs/README.md | 8 + docs/memory-research.md | 351 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 359 insertions(+) create mode 100644 docs/memory-research.md diff --git a/docs/README.md b/docs/README.md index 55ed45c..74c9be2 100644 --- a/docs/README.md +++ b/docs/README.md @@ -11,6 +11,9 @@ Documentation technique pour les composants audio (TTS/STT) et l'optimisation GP ### GPU - [GPU Optimization](gpu/optimization.md) - Optimisation VRAM et Ollama +### Memory +- [Memory Research](memory-research.md) - Comparatif des solutions de mémoire IA locales + --- ## 🗺️ Architecture Audio Actuelle @@ -87,6 +90,11 @@ Documentation technique pour les composants audio (TTS/STT) et l'optimisation GP 1. **Beszel** - Surveillance CPU/RAM/GPU 2. **Dozzle** - Logs Docker temps réel +### Memory (Mémoire IA) +1. **État actuel**: Mémoire manuelle via snippets OpenWebUI +2. **Mem0 abandonné**: Trop lent (5-10s/requête) +3. **Futur**: Améliorer RAG avec Qdrant, surveiller MemGPT + --- ## 🔗 Liens Utiles diff --git a/docs/memory-research.md b/docs/memory-research.md new file mode 100644 index 0000000..67fbcc4 --- /dev/null +++ b/docs/memory-research.md @@ -0,0 +1,351 @@ +# Recherche : Solutions de Mémoire pour IA Locale + +> **Date**: Avril 2026 +> **Contexte**: Projet Effi - Assistant IA Personnel Self-Hosted +> **Historique**: mem0 abandonné (trop lent), mémoire manuelle via snippets retenu + +--- + +## Table des Matières + +1. [Contexte et Besoins](#contexte-et-besoins) +2. [Niveaux de Mémoire IA](#niveaux-de-mémoire-ia) +3. [Solutions Actuelles](#solutions-actuelles) +4. [Comparatif Détaillé](#comparatif-détaillé) +5. [Intégration OpenWebUI](#intégration-openwebui) +6. [Innovations et Futur](#innovations-et-futur) +7. [Recommandations pour Effi](#recommandations-pour-eff) + +--- + +## Contexte et Besoins + +### Mémoire Actuelle Effi +- **Type**: Mémoire manuelle via snippets OpenWebUI +- **Avantages**: Rapide, prévisible, simple +- **Inconvénients**: Nécessite intervention manuelle, pas automatique + +### Besoins Identifiés +1. **Mémoire court terme**: Conversation actuelle (context window) +2. **Mémoire long terme**: Informations persistantes entre sessions +3. **Mémoire sémantique**: Recherche dans les documents +4. **Mémoire épisodique**: Faits importants sur l'utilisateur + +--- + +## Niveaux de Mémoire IA + +### Niveau 1 : Context Window (Mémoire Court Terme) +- **Description**: Fenêtre de contexte du modèle (32K pour qwen3.5) +- **Durée**: Session actuelle uniquement +- **Technologie**: Native au LLM + +### Niveau 2 : Mémoire de Travail (Working Memory) +- **Description**: Informations actives pendant une conversation +- **Durée**: Conversation en cours +- **Technologie**: RAG, snippets contextuels + +### Niveau 3 : Mémoire Long Terme (Long Term Memory) +- **Description**: Informations persistantes entre sessions +- **Durée**: Jours, semaines, mois +- **Technologie**: Vector DB, graphe de connaissances + +### Niveau 4 : Mémoire Épisodique +- **Description**: Faits importants sur l'utilisateur +- **Durée**: Permanente +- **Technologie**: KG, mem0, personnal knowledge graphs + +### Niveau 5 : Mémoire Procédurale +- **Description**: Comment faire les choses, préférences +- **Durée**: Apprentissage continu +- **Technologie**: LoRA, fine-tuning + +--- + +## Solutions Actuelles + +### 1. OpenWebUI Memories (Natif) ⭐ ACTUEL + +**Description**: Système de snippets intégré à OpenWebUI + +**Avantages**: +- ✅ Intégré nativement +- ✅ Simple et rapide +- ✅ Pas de latence supplémentaire +- ✅ Fonctionne avec Ollama + +**Inconvénients**: +- ❌ Manuel (snippets à créer) +- ❌ Pas de mémorisation automatique +- ❌ Limité en capacité + +**Utilisation**: +- `/memory` - Ajouter des souvenirs +- Snippets dans le contexte + +--- + +### 2. Mem0 (Abandonné par Effi) + +**Description**: Couche de mémoire gestion pour LLM, utilisant Qdrant + +**Statut**: ❌ ABANDONNÉ +- Latence 5-10s par requête +- Complexité d'installation +- Bugs de parsing avec Ollama + +**Architecture**: +``` +User Message → Mem0 → Qdrant → Contexte enrichi → LLM +``` + +--- + +### 3. LangChain Memory + +**Description**: Framework Python avec plusieurs types de mémoire + +**Types de mémoire**: +- ConversationBufferMemory +- ConversationSummaryMemory +- VectorStoreRetrievedMemory +- EntityMemory + +**Avantages**: +- ✅ Flexible +- ✅ Multiple backends (Redis, PostgreSQL, etc.) +- ✅ Bien documenté + +**Inconvénients**: +- ❌ Complexe +- ❌ Nécessite hébergement supplémentaire +- ❌ Latence variable + +--- + +### 4. LlamaIndex Memory + +**Description**: Framework RAG avec mémoire conversationnelle + +**Avantages**: +- ✅ Excellent pour RAG +- ✅ Memory over RAG +- ✅ Queries structurées + +**Inconvénients**: +- ❌ Python only +- ❌ Complexe pour usage simple + +--- + +### 5. Qdrant (RAG Sémantique) ⭐ UTILISÉ + +**Description**: Vector database pour recherche sémantique + +**Utilisation actuelle Effi**: +- Stockage des documents +- Recherche sémantique via bge-m3 +- RAG sur documents + +**Configuration**: +```yaml +VECTOR_DB: qdrant +QDRANT_URI: http://192.168.1.27:6333 +``` + +--- + +### 6. Personal Knowledge Graphs (PKG) + +**Description**: Graphe de connaissances personnel + +**Outils**: +- **Mem**: https://mem.ai (cloud) +- **Nexus**: https://nexus.minddrop.net (fermé) +- **Corallium**: Alternative open-source + +**Avantages**: +- ✅ Mémoire automatique +- ✅ Connections sémantiques +- ✅ Apprentissage continu + +**Inconvénients**: +- ❌多为 cloud +- ❌ Pas de solution self-hosted mature + +--- + +### 7. OpenWebUI Pipelines + Custom Memory + +**Description**: Framework de plugins pour OpenWebUI + +**Possibilités**: +- Custom memory pipeline +- Intégration avec Qdrant +- Personnalisation complète + +**Statut**: ❌ SUPPRIMÉ (trop complexe) + +--- + +### 8. Beeegf (Mémoire Distribuée) + +**Description**: Système de mémoire distribué pour agents + +**Avantages**: +- ✅ Pour agents multiples +- ✅ Mémoire partagée +- ✅ Open-source + +**Inconvénients**: +- ❌ Expérimental +- ❌ Documentation limitée + +--- + +## Comparatif Détaillé + +| Solution | Type | Latence | Complexité | Self-Hosted | État | +|----------|------|---------|------------|-------------|------| +| OpenWebUI Snippets | Manuel | ~0ms | Très basse | ✅ | ⭐ Actuel | +| Mem0 | Auto | 5-10s | Haute | ✅ | ❌ Abandonné | +| LangChain Memory | Hybrid | Variable | Haute | ✅ | ⚠️ Complexe | +| LlamaIndex | RAG | <1s | Moyenne | ✅ | ⚠️ Python | +| Qdrant (RAG) | Semantic | <1s | Basse | ✅ | ⭐ Actif | +| Knowledge Graph | Auto | <2s | Moyenne | ⚠️ | 🔬 Émergent | +| Ollama Context | Court | 0ms | Aucune | ✅ | ⭐ Actif | + +--- + +## Intégration OpenWebUI + +### Configuration Actuelle +```yaml +# OpenWebUI Settings +ENABLE_MEMORIES: true + +# Mémoire = Snippets manuels +# RAG = Qdrant (documents) +``` + +### Options d'Amélioration + +#### Option A : Améliorer Mémoire Manuelle +- Snippets plus structurés +- Prompts enrichis +- Routines de consolidation + +#### Option B : RAG Amélioré +- Indexation automatique des documents +- Métadonnées enrichies +- Retrieval optimisé + +#### Option C : Graph Memory (Future) +- Intégration knowledge graph +- Mémoire épisodique +- Apprentissage passif + +--- + +## Innovations et Futur + +### 1. Memory-Augmented LLMs + +**Technologies émergentes**: +- **Memento**: Mémoire externalisée pour LLM +- **Atlas**: Mémoire neurale sur NCEN +- **MemGPT**: Extensions de contexte pour LLMs + +**Principe**: +``` +LLM ←→ Memory Controller ←→ External Memory +``` + +### 2. Continual Learning + +**Défi**: Apprendre sans oublier + +**Approches**: +- LoRA adaptatif +- Elastic Weight Consolidation +- Progressive Neural Networks + +### 3. Retrieval-Augmented Generation (RAG) 2.0 + +**Innovations**: +- RAG sur mémoire conversationnelle +- Self-RAG (auto-évaluation) +- Corrective RAG + +### 4. Knowledge Graphs 2.0 + +**Évolutions**: +- Graphe de mémoire personnel +- Extraction automatique de faits +- Reasoning sur le graphe + +### 5. Agents avec Mémoire + +**Architectures**: +- Multi-agents avec mémoire partagée +- Hive mind pour tâches complexes +- Mémoire épisodique pour agents + +--- + +## Recommandations pour Effi + +### Court Terme (Maintenant) +1. **Garder mémoire manuelle** via snippets +2. **Optimiser RAG** avec Qdrant existant +3. **Structurer les prompts** pour meilleure rétention + +### Moyen Terme (3-6 mois) +1. **Tester LlamaIndex** pour mémoire conversationnelle +2. **Expérimenter avec knowledge graphs** (Obsidian + plugins) +3. **Automatiser l'indexation** des documents + +### Long Terme (6-12 mois) +1. **Surveiller Mem0** (peut s'améliorer) +2. **Explorer MemGPT** pour extensions de contexte +3. **Intégrer knowledge graph** personnel + +### Non Recommandé +- ❌ Retour à mem0 (trop de problèmes) +- ❌ LangChain (complexité inutile) +- ❌ Solutions cloud (vie privée) + +--- + +## Sources et Références + +### Documentation +- [Mem0 Documentation](https://docs.mem0.ai) +- [LangChain Memory](https://python.langchain.com/docs/concepts/memory) +- [LlamaIndex Memory](https://docs.llamaindex.ai/en/stable/module_guides/models/llms/cookbook/memory/) +- [OpenWebUI Memories](https://docs.openwebui.com/features/chat-conversations/memory) +- [Qdrant Documentation](https://qdrant.tech/documentation/) + +### Articles +- [Memory-Augmented Language Models (Stanford)](https://arxiv.org/abs/2210.14278) +- [MemGPT: Towards LLMs as Operating Systems](https://arxiv.org/abs/2312.04730) +- [RAG vs Fine-tuning vs Memories](https://www.promptlayer.com/blog/rag-vs-fine-tuning-vs-memories) + +### Projets +- [Mem0](https://github.com/mem0ai/mem0) +- [LangChain](https://github.com/langchain-ai/langchain) +- [LlamaIndex](https://github.com/run-llama/llama_index) +- [MemGPT](https://github.com/MemGPT/MemGPT) + +--- + +## Conclusion + +La mémoire pour IA locale est un **problème non résolu** de manière satisfaisante. Les solutions automatiques comme mem0 ajoutent trop de latence. La solution manuelle via snippets reste le **sweet spot** entre fonctionnalité et performance. + +**Pour Effi**: Garder l'approche actuelle et améliorer progressivement le RAG et les prompts plutôt que d'ajouter une couche de mémoire complexe. + +--- + +*Document créé: Avril 2026* +*Dernière mise à jour: Avril 2026*