Open Brain : construire une mémoire persistante pour tes IA en 45 minutes

#Le problème : chaque conversation repart de zéro

Tu ouvres un nouveau chat avec Claude, tu poses une question sur ton projet — et il ne se souvient de rien. Les décisions prises hier, le contexte technique accumulé, tes préférences : tout est effacé. Tu dois tout réexpliquer à chaque session.

Ce problème a un nom : l'amnésie conversationnelle. Les LLM sont stateless par conception. Leur fenêtre de contexte est temporaire — elle existe le temps d'une conversation et disparaît ensuite. Que tu utilises Claude, GPT, Gemini ou un modèle open-source, c'est pareil.

Résultat concret : tu perds du temps à répéter du contexte, l'IA rate des patterns qu'elle avait déjà identifiés, et tu ne capitalises jamais sur les échanges précédents.

#Le concept : un cerveau externe connecté par MCP

Open Brain repose sur trois composants :

1. Une base de données vectorielle — PostgreSQL avec l'extension pgvector — pour stocker tes connaissances sous forme de vecteurs numériques (embeddings)
2. Un serveur MCP — le pont entre ta base de données et n'importe quel outil IA compatible
3. Un modèle d'embedding — pour transformer du texte en vecteurs recherchables par similarité sémantique

Le principe est celui du RAG personnel (Retrieval-Augmented Generation) : au lieu de bourrer la fenêtre de contexte avec tout ce que tu sais, tu stockes tes connaissances dans une base externe et l'IA va chercher uniquement ce qui est pertinent au moment où elle en a besoin.

┌──────────────┐     ┌──────────────┐     ┌──────────────┐
│  Tes notes,  │────▶│  PostgreSQL  │────▶│  Serveur MCP │
│  décisions,  │     │  + pgvector  │     │              │
│  contexte    │     │ (embeddings) │     │  (pont IA)   │
└──────────────┘     └──────────────┘     └──────┬───────┘
                                                  │
                            ┌─────────────────────┼─────────────────────┐
                            │                     │                     │
                     ┌──────┴──────┐     ┌────────┴────┐     ┌─────────┴───┐
                     │   Claude    │     │    GPT      │     │   Gemini    │
                     │   Code      │     │             │     │             │
                     └─────────────┘     └─────────────┘     └─────────────┘

La force de cette architecture : elle est agnostique du modèle. Puisque la mémoire passe par MCP (le Model Context Protocol d'Anthropic), tout outil compatible peut y accéder — Claude Desktop, Cursor, Windsurf, GitHub Copilot.

#Pourquoi pgvector et pas une base vectorielle dédiée

Tu pourrais utiliser Pinecone, Qdrant ou Chroma. Mais PostgreSQL avec pgvector a trois avantages décisifs pour un usage personnel :

pgvector ajoute un type vector à PostgreSQL et une fonction de recherche par similarité cosinus. C'est tout. Tu gardes la puissance de SQL pour filtrer, trier et organiser tes données, avec la recherche sémantique en plus.

#Guide pratique : construire ton Open Brain

#Étape 1 — Créer la base de données

La solution la plus simple est Supabase, qui offre un PostgreSQL managé avec pgvector activé par défaut sur le free tier.

1. Crée un projet sur supabase.com
2. Va dans l'éditeur SQL et active l'extension :

CREATE EXTENSION IF NOT EXISTS vector;

3. Crée la table de mémoires :

CREATE TABLE memories (
  id BIGSERIAL PRIMARY KEY,
  content TEXT NOT NULL,
  embedding VECTOR(1536),
  tags TEXT[] DEFAULT '{}',
  metadata JSONB DEFAULT '{}',
  created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Index pour la recherche vectorielle rapide
CREATE INDEX ON memories
  USING ivfflat (embedding vector_cosine_ops)
  WITH (lists = 100);

Le champ embedding stocke des vecteurs de 1536 dimensions — c'est la taille des embeddings d'OpenAI text-embedding-3-small. Si tu utilises un modèle local (comme Qwen3-Embedding), adapte la dimension.

#Étape 2 — Comprendre les embeddings

Un embedding, c'est une représentation numérique du sens d'un texte. Quand tu transformes la phrase "Claude Code utilise des subagents" en embedding, tu obtiens un vecteur de 1536 nombres. Les textes qui parlent de sujets similaires produisent des vecteurs proches dans cet espace.

La recherche par similarité cosinus exploite cette propriété : quand tu poses une question, elle est aussi transformée en vecteur, et pgvector trouve les mémoires dont les vecteurs sont les plus proches.

#Étape 3 — Connecter un serveur MCP

Le serveur MCP fait le lien entre ta base et tes outils IA. Le projet open-source mcp-memory est une implémentation prête à l'emploi.

La configuration dans ton ~/.claude/settings.json (ou équivalent pour ton outil IA) :

{
  "mcpServers": {
    "memory": {
      "command": "node",
      "args": ["chemin/vers/mcp-memory/dist/index.js"],
      "env": {
        "DATABASE_URL": "postgresql://user:password@host:5432/dbname"
      }
    }
  }
}

Une fois configuré, ton IA a accès à de nouveaux outils :

• store_memory — sauvegarder un fait, une décision, un contexte
• search_memory — rechercher par similarité sémantique
• list_memories — parcourir les mémoires par tags ou date

#Étape 4 — Alimenter le cerveau

Le cerveau est vide au départ. Plusieurs stratégies pour le remplir :

Migration manuelle — Demande à ton IA de sauvegarder les points importants en fin de session :

Sauvegarde en mémoire : le projet blog-claude utilise Next.js 14
avec App Router, Tailwind CSS v4, et MDX pour le contenu.
Les articles sont dans content/posts/.

Capture automatique — Configure un prompt système qui demande à l'IA de sauvegarder automatiquement les décisions importantes, les bugs résolus et les préférences découvertes.

Import en masse — Si tu as des notes existantes (Notion, Obsidian, fichiers markdown), tu peux les transformer en embeddings et les insérer directement dans la table.

#Étape 5 — Utiliser la mémoire au quotidien

Une fois connecté, l'usage est transparent. Tu poses une question à Claude, et le serveur MCP permet de chercher dans tes mémoires les informations pertinentes. Le contexte est injecté automatiquement.

Exemples de requêtes qui déclenchent une recherche en mémoire :

• "Quelle architecture on avait choisie pour le module d'auth ?"
• "Quels bugs on a corrigés la semaine dernière ?"
• "Quelles sont mes préférences de stack technique ?"

#Coût réel de l'infrastructure

Le free tier de Supabase inclut 500 Mo de stockage et des milliers de requêtes par jour — largement suffisant pour un cerveau personnel. Le seul coût récurrent est l'API d'embedding, et à l'échelle personnelle (quelques centaines de requêtes par mois), on parle de 0,05 à 0,20 $.

Si tu veux éliminer ce coût entièrement, utilise un modèle d'embedding local comme gte-small ou Qwen3-Embedding-0.6B via Ollama. Le trade-off : la qualité de recherche est légèrement inférieure, mais le coût tombe à zéro.

#Alternatives open-source à connaître

Open Brain est un concept, pas un logiciel unique. Plusieurs projets open-source implémentent la même idée avec des approches différentes :

Khoj est le plus mature : c'est un "second brain" complet avec interface web, ingestion de PDFs et Notion, et support de tous les LLM (cloud et local via Ollama). Si tu veux une solution clé en main, c'est le meilleur point de départ.

Mem0 se positionne comme couche mémoire universelle pour agents IA. Il extrait automatiquement des faits des conversations, gère les conflits (si une information contredit une mémoire existante), et supporte plus de 20 bases vectorielles différentes.

SimpleMem est l'approche académique : un pipeline de compression sémantique qui utilise 30 fois moins de tokens que Mem0 pour une précision supérieure, grâce à un modèle d'embedding local (Qwen3-Embedding-0.6B) et une recherche hybride (vecteurs + BM25 + métadonnées).

#Les limites à connaître

Avant de te lancer, quelques points de vigilance :

• La qualité dépend de l'embedding. Si tu stockes des mémoires vagues ("on a parlé du truc"), la recherche sémantique retournera des résultats vagues. Sois précis et structuré dans ce que tu sauvegardes.
• Pas de raisonnement sur les mémoires. Le cerveau stocke et retrouve de l'information, mais il ne fait pas de synthèse automatique. C'est le LLM qui raisonne sur les mémoires récupérées.
• La maintenance existe. Au fil du temps, certaines mémoires deviennent obsolètes. Il faut prévoir un mécanisme de nettoyage — même un simple passage en revue trimestriel.
• La latence augmente avec le volume. Avec des dizaines de milliers de mémoires, l'index ivfflat commence à montrer ses limites. Pour un usage personnel, tu n'atteindras probablement jamais ce seuil.

#Ce qu'il faut retenir

L'amnésie conversationnelle des IA n'est pas une fatalité — c'est un problème d'infrastructure que tu peux résoudre toi-même :

• PostgreSQL + pgvector fournit une base vectorielle gratuite et robuste
• MCP connecte cette base à n'importe quel outil IA compatible, sans vendor lock-in
• Le coût réel est de 0,10 à 0,30 $ par mois, voire zéro avec des embeddings locaux
• L'investissement temps est d'environ 45 minutes pour une première version fonctionnelle

Le plus important n'est pas l'outil choisi, mais le principe : ta connaissance t'appartient. En construisant ton propre cerveau externe, tu évites la dépendance à un fournisseur unique et tu gardes le contrôle total sur tes données.