- **Download-and-use and simple** to get started.
- Builds long-term memory to **understand user intent** and act proactively.
- **Cuts LLM token cost** with smaller context.
Try now: [memU bot](https://memu.bot)
---
## ⭐️ Mettez une étoile au dépôt
Si vous trouvez memU utile ou intéressant, une étoile GitHub ⭐️ serait grandement appréciée.
---
## ✨ Fonctionnalités Principales
| Capacité | Description |
|----------|-------------|
| 🤖 **Agent Proactif 24/7** | Agent de mémoire toujours actif qui travaille continuellement en arrière-plan—ne dort jamais, n'oublie jamais |
| 🎯 **Capture d'Intention Utilisateur** | Comprend et mémorise automatiquement les objectifs, préférences et contexte de l'utilisateur à travers les sessions |
| 💰 **Économique** | Réduit les coûts de tokens à long terme en cachant les insights et en évitant les appels LLM redondants |
---
## 🔄 Comment Fonctionne la Mémoire Proactive
```bash
cd examples/proactive
python proactive.py
```
---
### Proactive Memory Lifecycle
```
┌──────────────────────────────────────────────────────────────────────────────────────────────────┐
│ USER QUERY │
└──────────────────────────────────────────────────────────────────────────────────────────────────┘
│ │
▼ ▼
┌────────────────────────────────────────┐ ┌────────────────────────────────────────────────┐
│ 🤖 MAIN AGENT │ │ 🧠 MEMU BOT │
│ │ │ │
│ Handle user queries & execute tasks │ ◄───► │ Monitor, memorize & proactive intelligence │
├────────────────────────────────────────┤ ├────────────────────────────────────────────────┤
│ │ │ │
│ ┌──────────────────────────────────┐ │ │ ┌──────────────────────────────────────────┐ │
│ │ 1. RECEIVE USER INPUT │ │ │ │ 1. MONITOR INPUT/OUTPUT │ │
│ │ Parse query, understand │ │ ───► │ │ Observe agent interactions │ │
│ │ context and intent │ │ │ │ Track conversation flow │ │
│ └──────────────────────────────────┘ │ │ └──────────────────────────────────────────┘ │
│ │ │ │ │ │
│ ▼ │ │ ▼ │
│ ┌──────────────────────────────────┐ │ │ ┌──────────────────────────────────────────┐ │
│ │ 2. PLAN & EXECUTE │ │ │ │ 2. MEMORIZE & EXTRACT │ │
│ │ Break down tasks │ │ ◄─── │ │ Store insights, facts, preferences │ │
│ │ Call tools, retrieve data │ │ inject │ │ Extract skills & knowledge │ │
│ │ Generate responses │ │ memory │ │ Update user profile │ │
│ └──────────────────────────────────┘ │ │ └──────────────────────────────────────────┘ │
│ │ │ │ │ │
│ ▼ │ │ ▼ │
│ ┌──────────────────────────────────┐ │ │ ┌──────────────────────────────────────────┐ │
│ │ 3. RESPOND TO USER │ │ │ │ 3. PREDICT USER INTENT │ │
│ │ Deliver answer/result │ │ ───► │ │ Anticipate next steps │ │
│ │ Continue conversation │ │ │ │ Identify upcoming needs │ │
│ └──────────────────────────────────┘ │ │ └──────────────────────────────────────────┘ │
│ │ │ │ │ │
│ ▼ │ │ ▼ │
│ ┌──────────────────────────────────┐ │ │ ┌──────────────────────────────────────────┐ │
│ │ 4. LOOP │ │ │ │ 4. RUN PROACTIVE TASKS │ │
│ │ Wait for next user input │ │ ◄─── │ │ Pre-fetch relevant context │ │
│ │ or proactive suggestions │ │ suggest│ │ Prepare recommendations │ │
│ └──────────────────────────────────┘ │ │ │ Update todolist autonomously │ │
│ │ │ └──────────────────────────────────────────┘ │
└────────────────────────────────────────┘ └────────────────────────────────────────────────┘
│ │
└───────────────────────────┬───────────────────────────────┘
▼
┌──────────────────────────────┐
│ CONTINUOUS SYNC LOOP │
│ Agent ◄──► MemU Bot ◄──► DB │
└──────────────────────────────┘
```
---
## 🎯 Cas d'Usage Proactifs
### 1. **Recommandation d'Information**
*L'agent surveille les intérêts et affiche proactivement du contenu pertinent*
```python
# L'utilisateur recherche des sujets sur l'IA
MemU suit: historique de lecture, articles sauvegardés, requêtes de recherche
# Quand du nouveau contenu arrive:
Agent: "J'ai trouvé 3 nouveaux articles sur l'optimisation RAG qui
correspondent à vos recherches récentes sur les systèmes de
récupération. Un auteur (Dr. Chen) que vous avez cité a publié hier."
# Comportements proactifs:
- Apprend les préférences de sujets des patterns de navigation
- Suit les préférences de crédibilité auteur/source
- Filtre le bruit selon l'historique d'engagement
- Planifie les recommandations pour attention optimale
```
### 2. **Gestion d'Email**
*L'agent apprend les patterns de communication et gère la correspondance routinière*
```python
# MemU observe les patterns email au fil du temps:
- Templates de réponse pour scénarios courants
- Contacts prioritaires et mots-clés urgents
- Préférences de planning et disponibilité
- Variations de style d'écriture et de ton
# Assistance email proactive:
Agent: "Vous avez 12 nouveaux emails. J'ai rédigé des réponses pour 3
demandes routinières et marqué 2 éléments urgents de vos contacts
prioritaires. Dois-je aussi reprogrammer la réunion de demain
selon le conflit mentionné par John?"
# Actions autonomes:
✓ Rédiger des réponses contextuelles
✓ Catégoriser et prioriser la boîte de réception
✓ Détecter les conflits de planning
✓ Résumer les longs fils avec décisions clés
```
### 3. **Trading & Surveillance Financière**
*L'agent suit le contexte marché et le comportement d'investissement utilisateur*
```python
# MemU apprend les préférences de trading:
- Tolérance au risque des décisions historiques
- Secteurs et classes d'actifs préférés
- Patterns de réponse aux événements marché
- Déclencheurs de rééquilibrage de portefeuille
# Alertes proactives:
Agent: "NVDA a chuté de 5% en after-hours. Selon votre comportement passé,
vous achetez typiquement les baisses tech supérieures à 3%. Votre
allocation actuelle permet $2,000 d'exposition supplémentaire tout
en maintenant votre cible 70/30 actions-obligations."
# Surveillance continue:
- Suivre les alertes prix liées aux seuils définis
- Corréler événements d'actualité et impact portefeuille
- Apprendre des recommandations exécutées vs. ignorées
- Anticiper les opportunités de récolte de pertes fiscales
```
...
---
## 🗂️ Architecture de Mémoire Hiérarchique
Le système à trois couches de MemU permet à la fois **les requêtes réactives** et **le chargement proactif de contexte** :
| Couche | Usage Réactif | Usage Proactif |
|--------|---------------|----------------|
| **Ressource** | Accès direct aux données originales | Surveillance en arrière-plan des nouveaux patterns |
| **Élément** | Récupération de faits ciblée | Extraction en temps réel des interactions en cours |
| **Catégorie** | Vue d'ensemble au niveau résumé | Assemblage automatique de contexte pour anticipation |
**Avantages Proactifs:**
- **Auto-catégorisation**: Les nouvelles mémoires s'auto-organisent en sujets
- **Détection de Patterns**: Le système identifie les thèmes récurrents
- **Prédiction de Contexte**: Anticipe quelle information sera nécessaire ensuite
---
## 🚀 Démarrage Rapide
### Option 1: Version Cloud
Expérimentez la mémoire proactive instantanément:
👉 **[memu.so](https://memu.so)** - Service hébergé avec apprentissage continu 7×24
Pour un déploiement entreprise avec des workflows proactifs personnalisés, contactez **info@nevamind.ai**
#### API Cloud (v3)
| URL de Base | `https://api.memu.so` |
|-------------|----------------------|
| Auth | `Authorization: Bearer YOUR_API_KEY` |
| Méthode | Endpoint | Description |
|---------|----------|-------------|
| `POST` | `/api/v3/memory/memorize` | Enregistrer une tâche d'apprentissage continu |
| `GET` | `/api/v3/memory/memorize/status/{task_id}` | Vérifier le statut de traitement en temps réel |
| `POST` | `/api/v3/memory/categories` | Lister les catégories auto-générées |
| `POST` | `/api/v3/memory/retrieve` | Interroger la mémoire (supporte le chargement proactif de contexte) |
📚 **[Documentation Complète de l'API](https://memu.pro/docs#cloud-version)**
---
### Option 2: Auto-Hébergé
#### Installation
```bash
pip install -e .
```
#### Exemple de Base
> **Prérequis**: Python 3.13+ et une clé API OpenAI
**Tester l'Apprentissage Continu** (en mémoire):
```bash
export OPENAI_API_KEY=your_api_key
cd tests
python test_inmemory.py
```
**Tester avec Stockage Persistant** (PostgreSQL):
```bash
# Démarrer PostgreSQL avec pgvector
docker run -d \
--name memu-postgres \
-e POSTGRES_USER=postgres \
-e POSTGRES_PASSWORD=postgres \
-e POSTGRES_DB=memu \
-p 5432:5432 \
pgvector/pgvector:pg16
# Exécuter le test d'apprentissage continu
export OPENAI_API_KEY=your_api_key
cd tests
python test_postgres.py
```
Les deux exemples démontrent **les workflows de mémoire proactive**:
1. **Ingestion Continue**: Traiter plusieurs fichiers séquentiellement
2. **Auto-Extraction**: Création immédiate de mémoire
3. **Récupération Proactive**: Affichage de mémoire contextuel
Voir [`tests/test_inmemory.py`](../tests/test_inmemory.py) et [`tests/test_postgres.py`](../tests/test_postgres.py) pour les détails d'implémentation.
---
### Fournisseurs LLM et Embeddings Personnalisés
MemU supporte des fournisseurs LLM et embeddings personnalisés au-delà d'OpenAI. Configurez-les via `llm_profiles`:
```python
from memu import MemUService
service = MemUService(
llm_profiles={
# Profil par défaut pour les opérations LLM
"default": {
"base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
"api_key": "your_api_key",
"chat_model": "qwen3-max",
"client_backend": "sdk" # "sdk" ou "http"
},
# Profil séparé pour les embeddings
"embedding": {
"base_url": "https://api.voyageai.com/v1",
"api_key": "your_voyage_api_key",
"embed_model": "voyage-3.5-lite"
}
},
# ... autre configuration
)
```
---
### Intégration OpenRouter
MemU supporte [OpenRouter](https://openrouter.ai) comme fournisseur de modèles, vous donnant accès à plusieurs fournisseurs LLM via une seule API.
#### Configuration
```python
from memu import MemoryService
service = MemoryService(
llm_profiles={
"default": {
"provider": "openrouter",
"client_backend": "httpx",
"base_url": "https://openrouter.ai",
"api_key": "your_openrouter_api_key",
"chat_model": "anthropic/claude-3.5-sonnet", # N'importe quel modèle OpenRouter
"embed_model": "openai/text-embedding-3-small", # Modèle d'embedding
},
},
database_config={
"metadata_store": {"provider": "inmemory"},
},
)
```
#### Variables d'Environnement
| Variable | Description |
|----------|-------------|
| `OPENROUTER_API_KEY` | Votre clé API OpenRouter de [openrouter.ai/keys](https://openrouter.ai/keys) |
#### Fonctionnalités Supportées
| Fonctionnalité | Statut | Notes |
|----------------|--------|-------|
| Complétion de Chat | Supporté | Fonctionne avec n'importe quel modèle de chat OpenRouter |
| Embeddings | Supporté | Utilisez les modèles d'embedding OpenAI via OpenRouter |
| Vision | Supporté | Utilisez des modèles avec capacité vision (ex., `openai/gpt-4o`) |
#### Exécuter les Tests OpenRouter
```bash
export OPENROUTER_API_KEY=your_api_key
# Test de workflow complet (memorize + retrieve)
python tests/test_openrouter.py
# Tests spécifiques aux embeddings
python tests/test_openrouter_embedding.py
# Tests spécifiques à la vision
python tests/test_openrouter_vision.py
```
Voir [`examples/example_4_openrouter_memory.py`](../examples/example_4_openrouter_memory.py) pour un exemple complet fonctionnel.
---
## 📖 APIs Principales
### `memorize()` - Pipeline d'Apprentissage Continu
Traite les entrées en temps réel et met à jour la mémoire immédiatement:
```python
result = await service.memorize(
resource_url="path/to/file.json", # Chemin de fichier ou URL
modality="conversation", # conversation | document | image | video | audio
user={"user_id": "123"} # Optionnel: limiter à un utilisateur
)
# Retourne immédiatement avec la mémoire extraite:
{
"resource": {...}, # Métadonnées de ressource stockées
"items": [...], # Éléments de mémoire extraits (disponibles instantanément)
"categories": [...] # Structure de catégories auto-mise à jour
}
```
**Fonctionnalités Proactives:**
- Traitement sans délai—mémoires disponibles immédiatement
- Catégorisation automatique sans étiquetage manuel
- Référence croisée avec les mémoires existantes pour détection de patterns
### `retrieve()` - Intelligence Double Mode
MemU supporte à la fois **le chargement proactif de contexte** et **les requêtes réactives**:
#### Récupération basée sur RAG (`method="rag"`)
**Assemblage proactif de contexte** rapide utilisant les embeddings:
- ✅ **Contexte instantané**: Affichage de mémoire en sous-seconde
- ✅ **Surveillance en arrière-plan**: Peut s'exécuter continuellement sans coûts LLM
- ✅ **Score de similarité**: Identifie automatiquement les mémoires les plus pertinentes
#### Récupération basée sur LLM (`method="llm"`)
**Raisonnement anticipatoire** profond pour contextes complexes:
- ✅ **Prédiction d'intention**: LLM infère ce dont l'utilisateur a besoin avant de demander
- ✅ **Évolution de requête**: Affine automatiquement la recherche au fur et à mesure que le contexte se développe
- ✅ **Terminaison précoce**: S'arrête quand suffisamment de contexte est collecté
#### Comparaison
| Aspect | RAG (Contexte Rapide) | LLM (Raisonnement Profond) |
|--------|----------------------|---------------------------|
| **Vitesse** | ⚡ Millisecondes | 🐢 Secondes |
| **Coût** | 💰 Embedding seulement | 💰💰 Inférence LLM |
| **Usage proactif** | Surveillance continue | Chargement de contexte déclenché |
| **Meilleur pour** | Suggestions temps réel | Anticipation complexe |
#### Utilisation
```python
# Récupération proactive avec historique de contexte
result = await service.retrieve(
queries=[
{"role": "user", "content": {"text": "Quelles sont leurs préférences?"}},
{"role": "user", "content": {"text": "Parle-moi des habitudes de travail"}}
],
where={"user_id": "123"}, # Optionnel: filtre de portée
method="rag" # ou "llm" pour raisonnement plus profond
)
# Retourne des résultats contextuels:
{
"categories": [...], # Domaines thématiques pertinents (auto-priorisés)
"items": [...], # Faits de mémoire spécifiques
"resources": [...], # Sources originales pour traçabilité
"next_step_query": "..." # Contexte de suivi prédit
}
```
**Filtrage Proactif**: Utilisez `where` pour délimiter la surveillance continue:
- `where={"user_id": "123"}` - Contexte spécifique à l'utilisateur
- `where={"agent_id__in": ["1", "2"]}` - Coordination multi-agent
- Omettre `where` pour conscience de contexte globale
> 📚 **Pour la documentation API complète**, voir [SERVICE_API.md](../docs/SERVICE_API.md) - inclut les patterns de workflow proactif, configuration de pipeline et gestion des mises à jour en temps réel.
---
## 💡 Scénarios Proactifs
### Exemple 1: Assistant Toujours Apprenant
Apprend continuellement de chaque interaction sans commandes de mémoire explicites:
```bash
export OPENAI_API_KEY=your_api_key
python examples/example_1_conversation_memory.py
```
**Comportement Proactif:**
- Extrait automatiquement les préférences des mentions occasionnelles
- Construit des modèles de relation à partir des patterns d'interaction
- Affiche le contexte pertinent dans les conversations futures
- Adapte le style de communication basé sur les préférences apprises
**Meilleur pour:** Assistants IA personnels, support client qui se souvient, chatbots sociaux
---
### Exemple 2: Agent Auto-Améliorant
Apprend des logs d'exécution et suggère proactivement des optimisations:
```bash
export OPENAI_API_KEY=your_api_key
python examples/example_2_skill_extraction.py
```
**Comportement Proactif:**
- Surveille les actions et résultats de l'agent continuellement
- Identifie les patterns dans les succès et échecs
- Auto-génère des guides de compétences à partir de l'expérience
- Suggère proactivement des stratégies pour des tâches futures similaires
**Meilleur pour:** Automatisation DevOps, auto-amélioration d'agent, capture de connaissances
---
### Exemple 3: Constructeur de Contexte Multimodal
Unifie la mémoire à travers différents types d'entrée pour un contexte complet:
```bash
export OPENAI_API_KEY=your_api_key
python examples/example_3_multimodal_memory.py
```
**Comportement Proactif:**
- Référence croisée de texte, images et documents automatiquement
- Construit une compréhension unifiée à travers les modalités
- Affiche le contexte visuel lors de la discussion de sujets associés
- Anticipe les besoins d'information en combinant plusieurs sources
**Meilleur pour:** Systèmes de documentation, plateformes d'apprentissage, assistants de recherche
---
## 📊 Performance
MemU atteint **92.09% de précision moyenne** sur le benchmark Locomo à travers toutes les tâches de raisonnement, démontrant des opérations de mémoire proactive fiables.
