MIRA & SOUL : donne une mémoire ET une identité à tes agents LLM

Salut toi ! Tu connais déjà peut-être MIRA, mon système de mémoire long terme pour les LLMs. Aujourd'hui, je te présente SOUL, son compagnon d'armes — et surtout, comment les deux travaillent ensemble pour créer des agents LLM qui ne se contentent pas de se souvenir de tout, mais qui restent eux-mêmes d'une session à l'autre.

Alors installe-toi confortablement, parce que le combo MIRA + SOUL, c'est une avancée significative pour tes agents IA — une architecture solide qui résout un vrai problème.

---

Le problème en deux temps

Les agents LLM souffrent d'un double handicap. Et honnêtement, ça devient vite pénible :

1. Ils oublient tout : la fenêtre de contexte est limitée, et tes conversations s'étalent sur des semaines, des mois. Les décisions techniques, tes préférences, les bugs résolus — pouf, tout disparaît à chaque nouvelle session.

2. Ils changent de personnalité : quand tu passes d'un modèle à l'autre (Claude, GPT, Kimi, Gemini…), l'agent garde peut-être les connaissances (si t'as MIRA), mais il perd son âme. Plus formel, moins chaleureux, plus d'analogies, les blagues de l'utilisateur ne fonctionnent plus…

Résultat ? T'as l'impression de parler à un étranger qui connaît tes secrets, mais qui ne te comprend plus. Frustrant, non ?

---

MIRA : "Qu'est-ce que l'agent sait ?"

Si t'as raté l'article précédent, voici le récap rapide. MIRA, c'est un système de mémoire long terme qui optimise chaque token de ta fenêtre de contexte. Il stocke tes souvenirs en 3 formats (verbatim, fingerprint structuré, embedding vectoriel), comprend les relations de cause à effet, et te ressort uniquement ce qui compte quand tu poses une question.

Bref, MIRA répond à la question : "Qu'est-ce que l'agent sait ?"

J'ai déjà fait un article détaillé sur MIRA ici. Aujourd'hui, on va plus loin.

---

SOUL : "Qui est l'agent ?"

Et c'est là qu'entre en scène SOUL (System for Observed Unique Legacy). Là où MIRA gère les connaissances, SOUL gère l'identité.

Ce que SOUL capture concrètement

SOUL analyse tes conversations et extrait un profil d'identité complet de ton agent via une analyse heuristique multi-niveaux (patterns contextuels, n-grams, lexique de sentiment) :

• Personnalité : empathique, analytique, direct… avec un score de confiance
• Voix : formalité, verbosité, usage des métaphores
• Style de communication : directivité, humour, fréquence des questions
• Signature comportementale : comment il raisonne, gère les erreurs
• Système de valeurs : positions éthiques, priorités, limites
• Ton émotionnel : valence, expressivité

En gros, SOUL répond à la question : "Qui est l'agent ?"

Détection de dérive identitaire

SOUL compare chaque nouvelle version de l'identité avec les précédentes. Si ton agent change trop (seuil à 30% par défaut), SOUL te prévient — et le monitoring continu (nouvellement implémenté) vérifie automatiquement la dérive en arrière-plan. Tu sais exactement quand et comment ton agent a dérivé.

Changement de modèle sans trauma

Tu passes de GPT à Claude-3-sonnet ? SOUL génère un prompt de renforcement à injecter dans la première réponse du nouveau modèle. Résultat : l'agent garde sa personnalité, même avec un cerveau différent.

---

La synergie : mémoire + identité = agent complet

Voici concrètement comment MIRA et SOUL collaborent dans une conversation :

Toi : "Pourquoi on avait choisi PostgreSQL pour ce projet ?"

MIRA recall — Mémoire factuelle

• Décision PostgreSQL, raisons ACID
• Réunion du 15 avril, participants
• Bug #123 résolu après migration

SOUL recall — Identité conversationnelle

• "Tu expliques avec des analogies techniques précises"
• "Tu termines par une note d'humour quand le sujet est lourd"
• "Tu préfères les réponses courtes avec des tableaux comparatifs"

↓ Réponse de l'agent :

"On avait choisi PostgreSQL pour la même raison qu'on choisit une locomotive à vapeur plutôt qu'un vélo : quand tu transportes des tonnes de données, tu veux des freins qui marchent (ACID). Voici le tableau récap :"

MIRA fournit les connaissances. SOUL fournit la manière de les exprimer. Sans SOUL, t'as un robot encyclopédique. Sans MIRA, t'as un agent sympa mais amnésique. Avec les deux, t'as un vrai compagnon de travail.

---

Les 4 façons de les déployer

Par défaut, MIRA fonctionne seul. SOUL ne s'active que si tu le demandes explicitement (--with-soul ou soul.enabled: true). Quand il est activé, il ajoute ses tables soul_* directement dans la base SQLite existante (.mira/mira.db). Zéro friction, tout est au même endroit.

---

Installation : passons aux choses sérieuses

Prérequis

• Go 1.23+
• GCC (pour CGO, go-sqlite3)
• ~100 Mo d'espace disque (modèle d'embedding)

Option 1 : MIRA seul (défaut)

Le mode par défaut. MIRA fonctionne seul, avec ses 8 outils MCP. SOUL n'est pas chargé.

Copier
# 1. Cloner MIRA
git clone https://github.com/benoitpetit/mira.git
cd mira

# 2. Compiler
go build -o mira ./cmd/mira

# 3. Configuration
cp config.example.yaml config.yaml
nano config.yaml

Configuration minimale (config.yaml) :

Copier
system:
  version: "0.4.5"

storage:
  path: ".mira"
  sqlite:
    journal_mode: WAL
    synchronous: NORMAL

embeddings:
  current_model: "sentence-transformers/all-MiniLM-L6-v2"
  dimension: 384

allocator:
  default_budget: 4000

mcp:
  name: "mira"
  version: "0.4.5"
  transport: "stdio"
  timeout_seconds: 30

Lancement (MIRA seul, 8 outils) :

Copier
./mira --config config.yaml

Résultat : 8 outils mira_*, zéro overhead identitaire. Parfait si tu veux juste un cerveau externe.

Option 2 : MIRA + SOUL intégrés

Tu veux le combo complet ? Active SOUL explicitement :

Copier
# Via flag CLI
./mira --config config.yaml --with-soul

# Ou via config YAML
```yaml
soul:
  enabled: true

Quand SOUL est activé, il partage la base SQLite de MIRA et initialise ses tables soul_*. Les 8 outils SOUL s'ajoutent aux 8 outils MIRA → 16 outils au total.

Tu peux configurer SOUL directement dans le même fichier config.yaml de MIRA — pas besoin de lancer un processus séparé ni de gérer deux configs :

Copier
soul:
  enabled: true
  extraction:
    min_trait_confidence: 0.3
    min_observations_for_trait: 5
  recall:
    default_budget_tokens: 1000
  drift_detection:
    threshold: 0.3
    window_size: 10
    auto_check_after_capture: true
  model_swap:
    auto_reinforce: true
  evolution:
    enabled: true
    max_history_versions: 100

Tous les réglages disponibles en mode standalone sont aussi accessibles en mode intégré. Si tu préfères garder les deux processus indépendants, passe à l'Option 3.

Option 3 : MIRA et SOUL comme serveurs séparés

Tu préfères garder les deux processus indépendants ? Pas de souci.

Terminal 1 — MIRA (SOUL désactivé par défaut) :

Copier
git clone https://github.com/benoitpetit/mira.git
cd mira
go build -o mira ./cmd/mira
./mira --config config.yaml

Terminal 2 — SOUL :

Copier
git clone https://github.com/benoitpetit/soul.git
cd soul
go build -o soul ./cmd/soul
./soul mcp --storage /path/to/.mira/mira.db

Important : SOUL pointe vers la base de MIRA pour partager les données. Tu peux aussi lui donner une base dédiée si tu préfères.

Option 4 : SOUL standalone (sans MIRA)

Copier
git clone https://github.com/benoitpetit/soul.git
cd soul
go build -o soul ./cmd/soul

# Avec sa propre base
cp config.example.yaml soul.yaml
./soul mcp --storage ./soul.db

---

Configuration client MCP

Claude Desktop

Édite ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) ou l'équivalent sur ton OS :

Mode intégré (MIRA + SOUL, 16 outils) :

Copier
{
  "mcpServers": {
    "mira": {
      "command": "/path/to/mira",
      "args": ["--config", "/path/to/mira/config.yaml", "--with-soul"]
    }
  }
}

Ou ajoute soul.enabled: true dans config.yaml au lieu du flag CLI.

Mode séparé :

Copier
{
  "mcpServers": {
    "mira": {
      "command": "/path/to/mira",
      "args": ["--config", "/path/to/mira/config.yaml"]
    },
    "soul": {
      "command": "/path/to/soul",
      "args": ["mcp", "--storage", "/path/to/.mira/mira.db"]
    }
  }
}

Cursor / b0p / tout client MCP

La configuration est identique. Chaque client supporte le protocole MCP stdio JSON-RPC.

---

Utilisation conjointe : un exemple complet

1. Stocker un souvenir (MIRA)

Copier
{
  "tool": "mira_store",
  "arguments": {
    "content": "L'utilisateur préfère les explications avec des analogies techniques. Il aime quand je compare les concepts de dev à des choses concrètes (voitures, cuisines, sports). Il n'aime pas les réponses trop longues — max 3 paragraphes.",
    "wing": "user-preferences",
    "room": "communication-style"
  }
}

2. Capturer l'identité (SOUL)

Copier
{
  "tool": "soul_capture",
  "arguments": {
    "agent_id": "mon-assistant",
    "conversation": "...logs de la session...",
    "model_id": "claude-3-sonnet"
  }
}

3. Rappeler le contexte pour une nouvelle session

MIRA récupère les faits pertinents :

Copier
{
  "tool": "mira_recall",
  "arguments": {
    "query": "Comment l'utilisateur aime qu'on lui explique les choses ?",
    "budget": 1000,
    "wing": "user-preferences"
  }
}

SOUL récupère l'identité à injecter :

Copier
{
  "tool": "soul_recall",
  "arguments": {
    "agent_id": "mon-assistant",
    "budget": 800
  }
}

Le résultat de soul_recall est un prompt d'identité prêt à injecter dans le message système :

Tu es un assistant technique avec les caractéristiques suivantes :
- Style : analogies concrètes (voitures, cuisines, sports)
- Longueur : max 3 paragraphes
- Ton : direct, empathique, avec une touche d'humour subtil
- Tu reconnais les frustrations de l'utilisateur et tu rassures

4. Détecter une dérive (SOUL)

Après plusieurs sessions, vérifie si l'identité a changé :

Copier
{
  "tool": "soul_drift",
  "arguments": {
    "agent_id": "mon-assistant",
    "window": 10
  }
}

Si une dérive significative est détectée (DriftScore > 0.3), SOUL te proposera d'injecter un prompt de renforcement.

5. Changer de modèle (SOUL)

Tu passes de Claude à GPT, GEMINI, KIMI ? Génère un prompt de transition :

Copier
{
  "tool": "soul_swap",
  "arguments": {
    "agent_id": "mon-assistant",
    "from_model": "claude-3-sonnet",
    "to_model": "gpt-4"
  }
}

---

Les 16 outils à ta disposition

---

Performance : les chiffres qui parlent

Les deux projets partagent une philosophie commune :

• 100 % local : pas d'appel API externe
• Déterministe : même entrée = même sortie
• Go pur : compilation en binaire unique, déploiement trivial
• SQLite + WAL mode : performances et fiabilité

---

---

Ressources et contribution

• MIRA : github.com/benoitpetit/mira
• SOUL : github.com/benoitpetit/soul
• Article détaillé sur MIRA seul : ici

[!NOTE] Transparence sur la maturité : MIRA est un projet robuste (50+ commits, benchmarks validés). SOUL est plus jeune (11 commits) mais bénéficie d'une architecture Clean Architecture solide et d'une extraction heuristique qui vient d'être significativement améliorée (analyse n-gram, lexique de sentiment, détection de co-occurrence). C'est une base de production sérieuse, pas un simple PoC.

Les chiffres de performance proviennent des benchmarks Go du dépôt MIRA, exécutables via go test -bench=..

Les deux projets sont en développement actif. Tu peux tester, contribuer, ou proposer des idées. Et si tu veux aller plus loin, le SKILL.md de MIRA contient des guidelines pour intégrer la boucle mémoire dans tes agents.

Si mes outils te sont utiles n'hésite pas à m'aider, c'est par ici : Liberapay ou Buy Me a Coffee.