YourMemory

Votre IA a la mémoire d'un poisson rouge. Plus maintenant.

Mémoire persistante et auto-améliorante pour agents IA — conçue sur la science de la mémoire humaine.

▶ Essayez la démo interactive en direct · Site Web · Benchmarks

Le problème

Chaque matin, votre agent IA vous traite comme un inconnu. Même contexte réexpliqué. Mêmes préférences oubliées. Chaque session repart de zéro.

La plupart des outils de « mémoire » ajoutent une base vectorielle à un agent et l'appellent mémoire – mais ce n'est que du stockage. Ils accumulent chaque quasi-doublon jusqu'à ce que la récupération se noie dans le bruit. Un poisson rouge avec un plus grand bocal.

YourMemory est différent : une mémoire qui fonctionne comme un cerveau, pas comme une base de données.

flowchart LR
    A["🧠 Vous dites quelque<br/>chose à votre IA"] --> B["Extraire les faits<br/>durables"]
    B --> C["Déduplication +<br/>embedding + lien<br/>de graphe"]
    C --> D[("Stockage<br/>mémoire")]
    D -->|"les faits connexes s'accumulent"| E["✨ Consolidation<br/>N → 1 résumé"]
    D -->|"obsolète + non utilisé"| F["📉 Déclin<br/>+ élagage"]
    D -->|"nouvelle session"| G["♻️ Rappel<br/>hybride + graphe"]
    E --> D
    G --> H["🤖 Votre agent<br/>reprend là où<br/>il s'est arrêté"]
    style D fill:#0a2540,stroke:#19cdff,color:#fff
    style E fill:#0c2b3a,stroke:#5eead4,color:#fff
    style H fill:#0c2b3a,stroke:#19cdff,color:#fff

✨ Ce qui le rend différent

Une seule commande à installer. DuckDB par défaut (zéro configuration), Postgres + pgvector pour les équipes.

Table des matières

• 🏆 Benchmarks
• 🚀 Démarrage rapide
• 🧠 Comment fonctionne la mémoire
  • Consolidation
  • Déclin
  • Rappel hybride
• 🔒 Confiance et piste d'audit
• 👥 Pools de mémoire d'équipe
• 🛡️ Droits sur les données et conformité
• 🎛️ Tableaux de bord
• 🔧 Outils MCP
• ⚡ Question sans appel LLM
• 🔀 Proxy API — Mémoire garantie
• 🏗️ Architecture et pile technique
• 🩺 Dépannage
• 🤝 Contribuer

🏆 Benchmarks

Trois jeux de données externes. Chaque chiffre est reproductible indépendamment — le code des benchmarks est dans le dépôt. Méthodologie complète dans BENCHMARKS.md.

LoCoMo-10 — mémoire conversationnelle multi-session

xychart-beta
    title "Recall@5 · LoCoMo-10 (plus c'est haut, mieux c'est)"
    x-axis ["Mem0", "Zep Cloud", "Supermemory", "YourMemory"]
    y-axis "Recall@5 percent" 0 --> 70
    bar [18, 28, 31, 59]

Rappel 2× meilleur que Zep Cloud sur l'ensemble des 10 échantillons. *Supermemory et Mem0 ont épuisé leurs quotas gratuits en cours de benchmark ; scores calculés sur la totalité des 1 534 paires.

LongMemEval-S — 500 questions, ~53 sessions distractrices chacune

Le benchmark standard le plus difficile pour la mémoire à long terme. Chaque question est enfouie dans ~53 sessions.

HotpotQA — 200 questions multi-sauts

Les arêtes du graphe d'entités ajoutent +12 pp — elles traversent du Fait 1 au Fait 2 même lorsque le Fait 2 a une faible similarité d'embedding avec la requête.

Article : J'ai construit le déclin de mémoire pour agents IA en utilisant la courbe d'oubli d'Ebbinghaus

🚀 Démarrage rapide

Python 3.11–3.14. Pas de Docker, pas de configuration de base de données. Toute la mémoire est stockée localement dans ~/.yourmemory/.

pip install yourmemory
yourmemory-register <votre-token>
yourmemory-setup

Obtenez votre token : visitez yourmemoryai.xyz → entrez votre email → vérifiez avec un code à 6 chiffres → copiez votre token.

yourmemory-setup détecte et configure automatiquement Claude Code, Claude Desktop, Cursor, Windsurf et Cline, puis demande quel backend utiliser :

• DuckDB — zéro configuration, un seul fichier local (par défaut)
• Postgres — partagé / production ; vous fournissez une DATABASE_URL (nécessite l'extension pgvector)

Optionnel — extraction locale plus intelligente : YourMemory fonctionne prêt à l'emploi avec des heuristiques intégrées. Pour une extraction de faits de meilleure qualité et entièrement locale, installez Ollama et yourmemory-setup télécharge automatiquement le modèle (qwen2.5:7b, ~4,7 Go). Vous préférez le cloud ? Définissez YOURMEMORY_EXTRACT_BACKEND=anthropic.

Ou installez depuis un binaire — pas besoin de Python

Vous ne voulez pas toucher à pip ? Récupérez le binaire autonome pour votre plateforme dans la dernière version :

# macOS / Linux — téléchargez, extrayez, exécutez
tar -xzf yourmemory-macos-arm64.tar.gz
./yourmemory-macos-arm64 register <votre-token>
./yourmemory-macos-arm64 setup
./yourmemory-macos-arm64            # démarre le serveur

Un seul exécutable gère toutes les commandes : register, setup, ask "<question>", path et (sans arguments) démarre le serveur.

Entièrement autonome et hors ligne – le binaire embarque Python, chaque dépendance et les deux modèles ML (le modèle d'embedding + spaCy). Rien n'est téléchargé au premier lancement. Le compromis est la taille (~2 Go). Construisez le vôtre avec une seule commande — ./build-binary.sh — et les binaires multi-plateformes sont produits automatiquement par le workflow de build.

🧠 Comment fonctionne la mémoire

YourMemory considère la mémoire comme un système vivant — elle grandit, se consolide, oublie et se connecte, comme un cerveau.

Consolidation — N → 1

La plupart des outils de mémoire ne font que s'agrandir. YourMemory surveille les groupes de faits connexes et, une fois qu'ils sont suffisamment nombreux, les compresse en un seul résumé propre — archivant les originaux (ne supprime jamais, donc rien n'est perdu).

flowchart LR
    subgraph before [Les faits connexes s'accumulent]
        A1["Railway utilise Nixpacks"]
        A2["Railway sur le plan Pro"]
        A3["Les variables d'env de<br/>Railway contiennent l'URL<br/>de Postgres"]
        A4["Déploiements sur Railway<br/>avec Postgres"]
    end
    before --> C{"regroupement +<br/>résumé LLM"}
    C --> S["✨ Résumé<br/>Déploie sur Railway (Pro,<br/>Nixpacks) avec Postgres<br/>via les vars d'env"]
    C -.->|"archivé, récupérable"| ARC[("archive")]
    style S fill:#0a2540,stroke:#5eead4,color:#fff
    style C fill:#0c2b3a,stroke:#19cdff,color:#fff

Exemple concret d'un stockage en production : 444 souvenirs → 16 résumés — même connaissance, une fraction du bruit. La consolidation est déclenchée par événement (lorsque les souvenirs connexes s'accumulent), pas une tâche aveugle de nuit.

Déclin — la courbe d'oubli

La force de la mémoire décroît de manière exponentielle. L'importance et la fréquence de rappel ralentissent ce déclin :

effective_λ  = base_λ × (1 − importance × 0,8)
strength     = clamp(importance × e^(−effective_λ × jours_actifs) × (1 + nb_rappels × 0,2), 0, 1)

jours_actifs ne compte que les jours où vous étiez actif — les vacances ne provoquent pas de perte de mémoire. Les souvenirs en dessous de 0,05 de force sont automatiquement élagués. Chaque catégorie vieillit à son propre rythme :

Élagage sensible au graphe : un souvenir en déclin est maintenu en vie si un voisin du graphe est encore fort — le contexte porteur de charge utile survit même lorsqu'il est rarement interrogé directement.

Rappel hybride — Vecteur + BM25 + Graphe

Le rappel se déroule en deux tours pour faire remonter à la fois ce que vous avez demandé et ce que vous avez oublié de demander :

flowchart LR
    Q["requête"] --> R1["Recherche hybride<br/>Vecteur + BM25"]
    R1 --> R2["Expansion par graphe<br/>(ce que vous avez<br/>oublié de demander)"]
    R2 --> S["classement par<br/>similarité × force"]
    S --> OUT["🎯 Souvenirs classés"]
    style OUT fill:#0a2540,stroke:#19cdff,color:#fff

Déduplication sensible au sujet est exécutée avant chaque stockage — elle intègre le sujet de chaque phrase pour que "Sachit utilise DuckDB" et "YourMemory utilise DuckDB" restent séparés (entités différentes), tandis que "YourMemory utilise DuckDB" et "YourMemory stocke les données dans DuckDB" fusionnent (même entité). Pas de listes de mots codées en dur ; généralisable à n'importe quelle langue.

🔒 Confiance et piste d'audit

Les entreprises ne laisseront pas une boîte noire opaque stocker leurs données. Donc chaque opération — lecture, écriture, mise à jour, suppression, consolidation — est ajoutée à un journal d'audit chaîné par hachage et inviolable.

flowchart LR
    E0["GENESIS"] --> E1
    subgraph E1 [Événement 1]
        H1["row_hash =<br/>sha256(prev + data)"]
    end
    E1 --> E2
    subgraph E2 [Événement 2]
        H2["row_hash =<br/>sha256(#1.hash + data)"]
    end
    E2 --> E3
    subgraph E3 [Événement 3]
        H3["row_hash =<br/>sha256(#2.hash + data)"]
    end
    E3 --> V{"GET /audit/verify"}
    V -->|chaîne intacte| OK["✅ vérifié"]
    V -->|une ligne modifiée| BAD["❌ chaîne rompue<br/>à cette ligne"]
    style OK fill:#0a2540,stroke:#5eead4,color:#fff
    style BAD fill:#3a0c14,stroke:#fb7185,color:#fff

Chaque ligne enregistre l'horodatage, l'acteur (utilisateur + agent), l'action, l'opération, la mémoire cible, la source (http vs mcp), et le hachage de la ligne précédente. Modifiez un enregistrement historique et verify_chain() identifie exactement où la chaîne s'est rompue.

GET  /audit            # parcourir la piste (filtrer par utilisateur / action / opération)
GET  /audit/verify     # vérifier cryptographiquement que la chaîne n'est pas altérée
POST /audit/prune      # nettoyage basé sur la rétention (minimum 90 jours, jamais moins)

La journalisation d'audit est en mode dégradé — elle ne bloque jamais une opération mémoire — et les événements de lecture/liste issus de la boucle de rendu du tableau de bord sont exclus, afin que la piste reste un signal, pas du bruit.

👥 Pools de mémoire d'équipe

Donnez à toute une équipe d'agents un cerveau partagé — sans fuite du contexte privé de chacun. Les souvenirs sont soit partagés (visibles par le pool) soit privés (visibles uniquement par leur propriétaire).

flowchart TB
    P(("🧠 Pool d'équipe<br/>mémoire partagée"))
    A["Agent d'Alice"] <-->|partagé| P
    B["Agent de Bob"] <-->|partagé| P
    C["Agent de Carol"] <-->|partagé| P
    A -. privé .-> AP["🔒 Alice uniquement"]
    B -. privé .-> BP["🔒 Bob uniquement"]
    style P fill:#0a2540,stroke:#19cdff,color:#fff
    style AP fill:#0c1424,stroke:#5a6b80,color:#8294a8
    style BP fill:#0c1424,stroke:#5a6b80,color:#8294a8

L'accès basé sur les rôles est appliqué par agent — ce que l'agent d'un ingénieur apprend, toute l'équipe en bénéficie instantanément ; le contexte sensible reste limité à son propriétaire.

POST   /pools                          # créer un pool
POST   /pools/{id}/members             # ajouter un membre (avec un rôle)
POST   /pools/{id}/memories            # contribuer à un souvenir partagé
POST   /pools/{id}/retrieve            # rappeler dans tout le pool

🛡️ Droits sur les données et conformité

Parce qu'une mémoire qui stocke des données réelles a besoin des contrôles pour être digne de confiance :

Combinés avec la piste d'audit chaînée par hachage et le plancher de rétention de 90 jours, ces éléments correspondent directement aux contrôles documentés dans SECURITY.md (alignés SOC 2).

🎛️ Tableaux de bord

Deux interfaces utilisateur intégrées dans le navigateur — aucune configuration supplémentaire, elles démarrent automatiquement avec le serveur.

Tableau de bord mémoire — http://localhost:3033/ui

Une vue complète en lecture/écriture avec les onglets Souvenirs · Audit · Pools : barre de statistiques (Fort / En déclin / Bientôt élagué), onglets par agent, cartes de souvenirs avec barres de force en direct, filtres par catégorie, la piste d'audit, et la gestion des pools.

Visualiseur de graphe — http://localhost:3033/graph

Une carte interactive à force dirigée de la connexion entre les souvenirs — le souvenir racine comme nœud lumineux, les voisins colorés par catégorie, l'épaisseur des arêtes = force de connexion. Faites glisser, zoomez et cliquez sur n'importe quel nœud pour voir son contenu complet.

http://localhost:3033/graph?memoryId=42&userId=alex&depth=2

🔧 Outils MCP

Trois outils, appelés automatiquement par votre IA.

# Stockage avec contexte spatial
store_memory(
    "Alex préfère les tabulations aux espaces en Python",
    importance=0.9, category="fact",
    context_paths=["/projects/backend"],
)

# Session suivante — le boost spatial se déclenche lorsqu'on travaille dans ce répertoire
recall_memory("Formatage Python", current_path="/projects/backend")
# → {"content": "Alex préfère les tabulations aux espaces en Python", "strength": 0.87}

⚡ Question sans appel LLM

Le seul système de mémoire capable de répondre à des questions sans effectuer aucun appel API LLM :

yourmemory ask "quelle base de données ce projet utilise-t-il"
# → YourMemory utilise DuckDB localement et Postgres en production.

yourmemory ask "comment corriger un déploiement Kubernetes"
# → Pas assez de contexte mémoire pour répondre sans LLM.

Lorsque la mémoire est suffisamment forte, elle répond instantanément — zéro token, zéro coût cloud, zéro latence. Lorsqu'elle ne l'est pas, elle décline proprement plutôt que d'halluciner. Votre requête ne quitte jamais votre machine.

🔀 Proxy API — Mémoire garantie

Les outils MCP sont appelés à la discrétion de l'IA. Le proxy API supprime cette incertitude — il intercepte chaque appel LLM, injecte automatiquement les souvenirs pertinents et gère store_memory / update_memory sans configuration de modèle.

Démarrez le serveur (yourmemory), puis pointez votre client vers localhost:3033 :

from anthropic import Anthropic

client = Anthropic(
    api_key="sk-ant-...",
    base_url="http://localhost:3033/proxy/anthropic",
    default_headers={"X-YourMemory-User": "alex"},  # mémoire par utilisateur
)

# La mémoire est injectée automatiquement — aucun autre changement nécessaire
response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Quelle base de données est-ce que j'utilise ?"}],
)

OpenAI fonctionne à l'identique via base_url="http://localhost:3033/proxy/openai".

🏗️ Architecture et pile technique

flowchart LR
    C["Votre client IA<br/>Claude · Cursor · tout MCP"] <--> Y["🧠 YourMemory"]
    Y --> M[("Stockage<br/>mémoire")]
    Y --> A[("Registre<br/>d'audit")]
    style Y fill:#0a2540,stroke:#19cdff,color:#fff
    style M fill:#0c1a2c,stroke:#5eead4,color:#fff
    style A fill:#0c1a2c,stroke:#5eead4,color:#fff

🩺 Dépannage

Les écritures bloquent / expirent (verrou d'écriture unique DuckDB). Si le serveur MCP et le serveur HTTP s'exécutent en même temps, ils se disputent le verrou d'écriture DuckDB. Correctif :

pkill -f yourmemory 2>/dev/null || true
rm -f ~/.yourmemory/memories.duckdb.wal ~/.yourmemory/memories.duckdb.lock 2>/dev/null || true
# redémarrez votre client

Vous utilisez Claude Desktop (MCP) et Claude Code (hooks) simultanément ? Utilisez SQLite à la place — il gère proprement les lectures/écritures concurrentes : DATABASE_URL=sqlite:///~/.yourmemory/memories.db

🤝 Contribuer

Les PRs sont les bienvenues — voir CONTRIBUTORS.md.

📚 Références des jeux de données

• LoCoMo — Maharana et al. (2024)
• LongMemEval — Wu et al. (2024)
• HotpotQA — Yang et al. (2018)

📄 Licence

Copyright 2026 Sachit Misra — Sous licence CC-BY-NC-4.0.

Gratuit pour usage personnel, éducation, recherche académique et projets open-source. Usage commercial nécessite un accord écrit séparé → [email protected]