OpenClaw (Moltbot, Clawdbot) Alternative

memU

Mémoire Proactive Toujours Active pour les Agents IA

English | 中文 | 日本語 | 한국어 | Español | Français

memU est un framework de mémoire conçu pour les agents proactifs 24/7. Il est conçu pour une utilisation prolongée et réduit considérablement le coût en tokens LLM pour maintenir les agents toujours en ligne, rendant les agents toujours actifs et évolutifs pratiques dans les systèmes de production. memU capture et comprend continuellement l'intention de l'utilisateur. Même sans commande, l'agent peut détecter ce que vous êtes sur le point de faire et agir de lui-même.

🤖 OpenClaw (Moltbot, Clawdbot) Alternative

• 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

🗃️ La Mémoire comme Système de Fichiers, le Système de Fichiers comme Mémoire

memU traite la mémoire comme un système de fichiers—structurée, hiérarchique et instantanément accessible.

Pourquoi c'est important :

• Naviguez dans les mémoires comme dans des répertoires—explorez des catégories larges jusqu'aux faits spécifiques
• Montez de nouvelles connaissances instantanément—les conversations et documents deviennent de la mémoire interrogeable
• Liez tout de manière croisée—les mémoires se référencent mutuellement, construisant un graphe de connaissances connecté
• Persistant et portable—exportez, sauvegardez et transférez la mémoire comme des fichiers

memory/
├── preferences/
│   ├── communication_style.md
│   └── topic_interests.md
├── relationships/
│   ├── contacts/
│   └── interaction_history/
├── knowledge/
│   ├── domain_expertise/
│   └── learned_skills/
└── context/
    ├── recent_conversations/
    └── pending_tasks/

Tout comme un système de fichiers transforme des octets bruts en données organisées, memU transforme les interactions brutes en intelligence structurée, recherchable et proactive.

⭐️ Mettez une étoile au dépôt

✨ Fonctionnalités Principales

🔄 Comment Fonctionne la Mémoire Proactive

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

# 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

# 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

# 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 :

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 - 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)

📚 Documentation Complète de l'API

Option 2: Auto-Hébergé

Installation

pip install -e .

Exemple de Base

Prérequis: Python 3.13+ et une clé API OpenAI

Tester l'Apprentissage Continu (en mémoire):

export OPENAI_API_KEY=your_api_key
cd tests
python test_inmemory.py

Tester avec Stockage Persistant (PostgreSQL):

# 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 et 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:

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 comme fournisseur de modèles, vous donnant accès à plusieurs fournisseurs LLM via une seule API.

Configuration

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

Fonctionnalités Supportées

Exécuter les Tests OpenRouter

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 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:

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

Utilisation

# 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 - 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:

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:

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:

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.

Voir les données expérimentales détaillées: memU-experiment

🧩 Écosystème

Liens Rapides:

• 🚀 Essayer MemU Cloud
• 📚 Documentation API
• 💬 Communauté Discord

🤝 Partenaires

🤝 Comment Contribuer

Nous accueillons les contributions de la communauté! Que vous corrigiez des bugs, ajoutiez des fonctionnalités ou amélioriez la documentation, votre aide est appréciée.

Pour Commencer

Pour commencer à contribuer à MemU, vous devrez configurer votre environnement de développement:

Prérequis

• Python 3.13+
• uv (gestionnaire de paquets Python)
• Git

Configurer l'Environnement de Développement

# 1. Fork et cloner le dépôt
git clone https://github.com/YOUR_USERNAME/memU.git
cd memU

# 2. Installer les dépendances de développement
make install

La commande make install va:

• Créer un environnement virtuel en utilisant uv
• Installer toutes les dépendances du projet
• Configurer les hooks pre-commit pour les vérifications de qualité de code

Exécuter les Vérifications de Qualité

Avant de soumettre votre contribution, assurez-vous que votre code passe toutes les vérifications de qualité:

make check

La commande make check exécute:

• Vérification du fichier lock: Assure la cohérence de pyproject.toml
• Hooks pre-commit: Lint le code avec Ruff, formate avec Black
• Vérification de types: Exécute mypy pour l'analyse de types statiques
• Analyse de dépendances: Utilise deptry pour trouver les dépendances obsolètes

Directives de Contribution

Pour des directives de contribution détaillées, standards de code et pratiques de développement, voir CONTRIBUTING.md.

Conseils rapides:

• Créer une nouvelle branche pour chaque fonctionnalité ou correction de bug
• Écrire des messages de commit clairs
• Ajouter des tests pour les nouvelles fonctionnalités
• Mettre à jour la documentation si nécessaire
• Exécuter make check avant de pousser

📄 Licence

Apache License 2.0

🌍 Communauté

• GitHub Issues: Signaler des bugs & demander des fonctionnalités
• Discord: Rejoindre la communauté
• X (Twitter): Suivre @memU_ai
• Contact: info@nevamind.ai

⭐ Mettez-nous une étoile sur GitHub pour être notifié des nouvelles versions!