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

Voici MIRA.

Salut ! Aujourd’hui, je te parle d’un projet qui me tient particulièrement à cœur : MIRA. Un système de mémoire à long terme pour les modèles de langage (LLMs), conçu pour optimiser chaque token dans la fenêtre de contexte. En gros, c’est comme un carnet de notes intelligent pour tes IA, mais en bien plus puissant et technique.

Le meilleur ? C’est 100 % local, déterministe, et open source. Pas de dépendance à des API externes, pas de black box, juste du code que tu peux auditer, modifier et héberger toi-même.

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 : tu discutes avec ton IA préférée depuis des semaines sur un projet. Tu lui as expliqué tes préférences, tes choix techniques, les bugs que tu as rencontrés… Puis, pouf, tu changes de sujet ou tu ouvres une nouvelle session. L’IA a tout oublié. Frustrant, non ?

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 cruciales.
• Résumé statique : ça ne s’adapte pas à la question posée.

MIRA, c’est la solution. Un système qui optimise chaque token en fonction de sa pertinence, de sa densité informationnelle, et de sa cohérence temporelle.

Comment MIRA révolutionne 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 va 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 ultra-puissant 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.

Le plus marrant ? J’ai même commencé à utiliser MIRA pour mes propres notes de développement ! C’est devenu mon "cerveau externe" pour les projets perso et pro.

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, c’est :

• Un système de mémoire ultra-puissant pour tes LLMs.
• Un outil open source et local, pour garder le contrôle.
• Une optimisation intelligente de chaque token.

Et toi ?!

• Comment tu gères la mémoire de tes IA ?
• Tu utilises des outils similaires ?
• Tu as des besoins spécifiques en mémoire étendue ?