title: Basic Memory created: 2026-06-07 updated: 2026-06-07 type: app tags: [catalogue, artificial-intelligence, mcp, knowledge-graph, markdown, obsidian, llm, python, agpl] confidence: high contested: false sources: [https://selfh.st/apps/?tag=artificial-intelligence, https://github.com/basicmachines-co/basic-memory]

Basic Memory 🧠

La couche de mémoire persistante pour vos IA — MCP server local-first qui transforme vos notes Markdown en graphe de connaissances interrogeable par Claude / Cursor / ChatGPT / Codex, et qui recontextualise automatiquement l'IA à chaque nouvelle conversation.

Métadonnée	Valeur
Site web	https://basicmemory.com
GitHub	https://github.com/basicmachines-co/basic-memory
License	AGPL-3.0
Langage	Python (82 %), HTML (14 %), TypeScript (4 %)
Étoiles	209
Dernière MAJ	2026-06-05 (v0.21.6)
Catégorie	cat-artificial-intelligence

📝 Description

Basic Memory résout un problème que tout utilisateur intensif de LLM a rencontré : « j'ai déjà expliqué 5 fois à Claude l'architecture de mon projet, et il ne s'en souvient jamais ». La solution : un serveur MCP (Model Context Protocol) qui lit et écrit des fichiers Markdown structurés sur votre disque, et qui reconstruit à la volée un graphe de connaissances reliant observations, personnes, projets, dates, concepts. Quand vous démarrez une conversation avec Claude Code, Basic Memory injecte automatiquement le contexte pertinent (le projet sur lequel vous travaillez, les décisions passées, les TODOs en cours) — fini le copier-coller, fini les re-explications.

L'architecture est local-first : vos notes restent en texte brut Markdown sur votre disque, vous pouvez les ouvrir dans Obsidian, VS Code, Neovim ou n'importe quel éditeur. Les fichiers sont parsés pour en extraire les observations (assertions) et les wikilinks [[app-xxx]] (relations), puis indexés dans une base vectorielle pour la recherche sémantique. Côté IA, Basic Memory expose une dizaine d'outils MCP (read_note, write_note, search_notes, edit_note, delete_note, build_context, etc.) que n'importe quel client MCP peut consommer : Claude Desktop, Claude Code, Cursor, VS Code, Codex, ChatGPT (via Custom GPT actions), et même Continue sur VS Code.

Le projet est porté par Basic Machines Co. (équipe réduite, soutenu par une communauté Discord active) et compte 3 200 ⭐, 209 forks, 84 releases (v0.21.6, 1 405 commits). Une offre Cloud existe à 15 $/mois (sync multi-device, hosting Tigris S3, WorkOS Auth, Neon Postgres) mais le code et le mode local sont 100 % gratuits et open source sous AGPL-3.0. Idéal pour les power-users qui font de l'IA un vrai compagnon de travail quotidien.

🚀 Installation

Option 1 : via `uv` (recommandé, le plus simple)

# Installation avec uv (gestionnaire Python moderne)
uv tool install basic-memory

# Lancement du daemon + UI
basic-memory start

Ouvrez http://localhost:8742 (UI web par défaut). C'est tout : la mémoire est initialisée dans ~/basic-memory/.

Option 2 : Docker Compose (auto-hébergé)

# docker-compose.yml
services:
  basic-memory:
    build: https://github.com/basicmachines-co/basic-memory.git
    container_name: basic-memory
    restart: unless-stopped
    ports:
      - "8742:8742"
    volumes:
      - ./notes:/app/notes              # vos notes Markdown (persistant)
      - ./db:/app/db                    # base vectorielle locale
    environment:
      - TZ=Europe/Paris
      - BASIC_MEMORY_HOME=/app
      - EMBEDDING_PROVIDER=local        # local / openai / litellm
      - MCP_TRANSPORT=http              # http ou stdio
    healthcheck:
      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8742/health"]
      interval: 30s
      timeout: 5s
      retries: 3

Option 3 : Connexion à Claude Desktop / Claude Code

Ajoutez dans ~/.config/claude/claude_desktop_config.json (Claude Desktop) ou via claude mcp add (Claude Code) :

{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": ["basic-memory", "mcp"],
      "env": {
        "BASIC_MEMORY_HOME": "/home/vous/basic-memory"
      }
    }
  }
}

Redémarrez Claude Desktop : les outils read_note, write_note, search_notes, build_context apparaissent dans la palette.

⚙️ Configuration

La configuration se fait via variables d'environnement ou un fichier .env à la racine BASIC_MEMORY_HOME :

EMBEDDING_PROVIDER : local (modèle embarqué, lent mais privé), openai (rapide, envoie les notes à OpenAI), litellm (n'importe quel provider).
MCP_TRANSPORT : stdio (pour clients locaux) ou http (pour clients distants, type ChatGPT).
BASIC_MEMORY_HOME : chemin du répertoire de notes (défaut ~/basic-memory/).
Format de note : voir NOTE-FORMAT.md — utilise des observations (- [concept] contenu) et des relations (- [relation: type] [[autre_note]]).
Sync multi-device : par défaut, pas de sync. Vous pouvez utiliser git, Syncthing, ou passer à l'offre Cloud (15 $/mois) pour sync auto.

🔄 Alternatives

Open Source

Mem0 (mem0ai/mem0) — couche de mémoire pour agents, propriétaire-friendly, API cloud, pas de Markdown.
Letta (ex-Berkeley) — agents avec mémoire long-terme, code en Python, pas orienté notes humaines.
Quivr — second brain RAG, upload de fichiers mais pas d'édition Markdown collaborative.
Logseq — prise de notes outliner avec plugins GPT, mais l'IA ne vit pas dedans comme avec Basic Memory.
Obsidian + Smart Connections — plugin Obsidian pour interroger le vault, mais limité à l'éditeur.
app-obsidian — éditeur Markdown référent, lit/écrit le même format que Basic Memory.
app-ollama — backend LLM local qui peut être appelé par Basic Memory pour l'embedding.
app-open-webui — chat LLM, intégrable en parallèle.

Propriétaires (ce que Basic Memory remplace)

Mem0 Cloud ($0-$99/mois) — mémoire agnostique, mais pas de Markdown, pas d'Obsidian.
ChatGPT Memory — enfermée dans ChatGPT, propriétaire, opaque, non auditable.
Claude Projects — contexte par projet, pas de mémoire long-terme cross-projet.
Notion AI Memory — couplé à Notion, pas d'export.
Reflect.app — prise de notes + AI, payant ($10-15 $/mois), cloud-only.

🔐 Sécurité

Stockage local par défaut : vos notes sont des fichiers Markdown en clair sur votre disque, propriété totale. Pas de cloud obligatoire.
Embedding local : choisissez EMBEDDING_PROVIDER=local pour ne jamais envoyer le contenu de vos notes à un service tiers. L'embedding local est plus lent (~1-3 s par note) mais reste sur votre machine.
AGPL-3.0 : si quelqu'un fork Basic Memory et le distribue en SaaS, il doit publier ses modifications. C'est une protection forte pour un outil qui touche à votre mémoire intellectuelle.
Backup = sauvegarder le dossier : un simple tar czf backup.tar.gz ~/basic-memory/ (avec app-restic idéalement) suffit. Pas de base externe à backuper, c'est juste du texte.
Token GitHub : si vous utilisez le plugin Claude Code (claude plugin marketplace add basicmachines-co/basic-memory), il faut un PAT GitHub avec droits read:user et public_repo.
Cloud Basic Memory : si vous passez à 15 $/mois, lisez les CGU : les notes sont hébergées sur Tigris S3 et la base sur Neon Postgres, chiffrement at-rest activé mais l'opérateur peut techniquement lire. Exportez régulièrement depuis l'UI cloud.
MCP via stdio vs http : préférez stdio (le client MCP local lit/écrit sur votre disque) à http (exposition réseau, même en localhost).

📚 Ressources

Pages Liées

cat-artificial-intelligence — Catégorie AI
app-obsidian — Éditeur Markdown compatible
app-ollama — Backend LLM/embedding local
app-logseq — Alternative outliner
recettes-docker-compose — Templates Docker
securisation-home-lab — Sauvegardes, secrets

8.6 KiB Raw Blame History