MIRA : j'ai construit un cerveau long terme pour les LLMs, et voilà comment ça marche

Voici MIRA

J'ai créé MIRA pour répondre à un problème qui revenait dans mes agents : les informations utiles existaient, mais elles n'entraient jamais toutes dans la fenêtre de contexte. MIRA stocke ces souvenirs localement et sélectionne un budget réduit de passages pertinents avant chaque appel au modèle.

Le projet est open source et déterministe. Tu peux l'exécuter sur ta machine, inspecter les données enregistrées et adapter la stratégie de rappel à ton application.

Pourquoi j’ai créé MIRA ? Parce que je me suis rendu compte que les LLMs oubliaient trop vite. Les contextes sont limités, et pourtant, nos conversations et projets s’étalent sur des mois, voire des années. J’ai voulu donner une mémoire fiable et intelligente à mes outils.

Le problème : les LLMs ont la mémoire courte

Imagine que tu travailles avec un agent sur un projet pendant plusieurs semaines. Les décisions, les préférences et les bugs corrigés sont utiles, mais une nouvelle session ne peut pas tout reprendre.

Les approches classiques comme le RAG (Retrieval-Augmented Generation) ou les fenêtres glissantes ne suffisent pas :

• RAG : on récupère les infos les plus similaires, mais sans tenir compte de leur pertinence réelle.
• Fenêtre glissante : on perd les infos anciennes, même importantes.
• Résumé statique : ça ne s’adapte pas à la question posée.

MIRA traite ce problème comme une allocation de budget : quels souvenirs apporter maintenant, et lesquels laisser de côté ? Le score combine pertinence, densité, récence, recouvrement et cohérence temporelle.

Comment MIRA organise la mémoire des LLMs

1. L’allocation de budget de contexte (CBA)

MIRA ne se contente pas de stocker et récupérer. Il résout un problème d’optimisation sous contrainte : comment maximiser l’information utile dans une fenêtre de tokens limitée ?

Pour chaque souvenir, MIRA calcule un score composite établi sur 6 dimensions :

• Pertinence sémantique (est-ce que ça correspond à ta question ?)
• Densité informationnelle (combien de faits utiles par token ?)
• Récence (est-ce récent ou important ?)
• Recouvrement (évite de prendre deux fois la même info)
• Cohérence temporelle (est-ce que ça s’inscrit dans une histoire logique ?)
• Pénalité causale (évite les chaînes de raisonnement trop longues)

Résultat ? Tu récupères uniquement ce qui compte, sans gaspiller un seul token.

Exemple concret : Tu demandes à ton IA : "Pourquoi on a choisi PostgreSQL ?" MIRA peut te sortir uniquement :

• La décision finale (PostgreSQL)
• Les alternatives rejetées (MySQL, MongoDB)
• Les raisons (ACID, expertise de l’équipe)
• Le lien vers la discussion originale

2. L’architecture 3 niveaux (T0/T1/T2)

Pour coller à la façon dont notre cerveau mémorise, MIRA stocke chaque souvenir en 3 formats :

Pourquoi 3 niveaux ? Parce que notre cerveau ne mémorise pas tout avec la même précision. MIRA fait pareil : tout est accessible, mais optimisé pour l’usage.

3. Le graphe causal intégré

MIRA ne se contente pas de rappeler des faits. Il comprend les liens de cause à effet entre tes souvenirs. Par exemple :

• "On a choisi PostgreSQL parce que l’équipe maîtrisait mieux ce SGBD."
• "Le bug a été résolu après la mise à jour de la librairie."

MIRA détecte automatiquement ces relations grâce à des motifs linguistiques (ex: "parce que", "après", "résout").

4. Un algorithme optimisé (O(n log n))

MIRA utilise :

• HNSW pour la recherche vectorielle (~0.14 ms pour 10 K vecteurs, benchmarké).
• SQLite pour le stockage (mode WAL pour la performance).
• Go pour la simplicité et la performance.

Complexité algorithmique :

• Stockage : O(1)
• Recherche : O(log n)
• Allocation de contexte : O(n²) (sélection gloutonne avec recalcule des scores)

Comment ça marche ?

Stockage d’un souvenir

Copier
# Envoi d'un souvenir à MIRA
{
  "tool": "mira_store",
  "arguments": {
    "content": "On a décidé de migrer vers PostgreSQL pour v2. Alternatives rejetées : MySQL (pas ACID), MongoDB (non relationnel). Raisons : ACID et expertise de l'équipe. Validé par CTO. Assigné à Jean.",
    "wing": "backend-team",
    "room": "database-migration"
  }
}

Récupération du contexte

Copier
# Demande de rappel, avec un budget de 2000 tokens
{
  "tool": "mira_recall",
  "arguments": {
    "query": "Pourquoi on a choisi PostgreSQL ?",
    "budget": 2000,
    "wing": "backend-team"
  }
}

Résultat :

=== CONTEXTE MIRA ===
Question : Pourquoi on a choisi PostgreSQL ? | Budget : 2000
Aile : backend-team

--- [1] EMPREINTE (45 tokens) ---
Décision : Migration PostgreSQL
Alternatives : MySQL, MongoDB
Raisons : ACID, expertise
Validé par : CTO
Assigné à : Jean

--- [2] TEXTE INTÉGRAL (120 tokens) ---
On a décidé de migrer vers PostgreSQL pour v2...
[contenu complet]

=== Total : 165/2000 tokens (8,3%) ===

Installation et utilisation

MIRA est conçu pour être simple à déployer :

1. Installation

Copier
# Via Go
go install github.com/benoitpetit/mira/cmd/mira@latest
# Ou téléchargez les binaires depuis les releases GitHub

2. Configuration

Copiez le fichier config.example.yaml et adaptez-le à ton besoin. Exemple :

Copier
storage:
  path: "./mira-data"  # Où stocker les données
embeddings:
  current_model: "sentence-transformers/all-MiniLM-L6-v2"
allocator:
  default_budget: 4000  # Taille de la fenêtre de contexte

3. Lancement

Copier
mira --config ./config.yaml

4. Utilisation avec tes outils IA

MIRA expose un serveur MCP (Model Context Protocol), compatible avec :

• Claude Desktop
• Cursor
• Obsidian
• Votre propre outil

Copier
{
  "mcpServers": {
    "mira": {
      "command": "mira",
      "args": []
    }
  }
}

Pourquoi choisir MIRA ?

• 100 % local : pas de fuite de données, pas de dépendance à des services externes.
• Déterministe : même résultat à chaque fois, pas de hasard (variance embedding < 1e-6).
• Optimisé : chaque token compte, pas de gaspillage.
• Open source : tu peux contribuer, auditer, modifier.
• Intégré : fonctionne avec tes outils existants via MCP.

Cas d’usage concrets

• Développement logiciel : garde une trace de tes décisions techniques, bugs résolus, et raisonnements.
• Gestion de projet : suis l’évolution des priorités et des choix.
• Recherche : stocke des références, des hypothèses, et des résultats intermédiaires.
• Journal personnel : un carnet de notes pour tes IA.

Mon retour d’expérience

Avant MIRA : Je passais des heures à réexpliquer mes choix à chaque session. Ou alors, je devais copier-coller manuellement mes notes. Avec MIRA : Mon IA se souvient de tout, et me rappelle les infos pertinentes en temps réel. Plus besoin de fouiller mes dossiers ou de reformuler.

Je l'utilise aussi pour mes notes de développement. C'est un cas d'usage plus simple qu'un agent autonome, mais il permet de vérifier rapidement si le rappel renvoie les bonnes décisions.

Comment contribuer ?

MIRA est en développement actif. Si tu veux :

• Tester et donner ton avis.
• Contribuer.
• Proposer des idées (features, améliorations).

Rejoins le projet sur GitHub !

En résumé

MIRA apporte :

• Une mémoire long terme locale pour tes LLMs.
• Une sélection de contexte qui respecte une limite de tokens.
• Une base open source que tu peux inspecter et adapter.

Si tu veux vérifier l'approche, le README de MIRA décrit les formats de stockage et les commandes disponibles. J'explique aussi comment la mémoire et l'identité vivent maintenant dans le même runtime, dans l'article MIRA : mémoire et identité intégrées.

Article co-écrit avec l'IA · Images générées avec l'IA.