---
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)

```bash
# 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é)

```yaml
# 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) :

```json
{
  "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](https://github.com/basicmachines-co/basic-memory/blob/main/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

- [GitHub basicmachines-co/basic-memory](https://github.com/basicmachines-co/basic-memory)
- [Site officiel](https://basicmemory.com)
- [Discord communauté](https://discord.gg/tyvKNccgqN)
- [Format des notes](https://github.com/basicmachines-co/basic-memory/blob/main/NOTE-FORMAT.md)
- [Smithery MCP registry](https://smithery.ai/)

## 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