Développeurs
Construis sur une mémoire
que tu ne possèdes pas.
Celle de ton utilisateur. Elle vit sur sa machine, elle est chiffrée, et il la gouverne — y compris contre toi. C'est la contrainte, et c'est ce qui rend le reste possible.
Ton propre code
Pointe-la sur ton projet. Elle en prend la mémoire.
Déclare le dossier de ton dépôt : Mnemosyne vectorise ton code — les fichiers, les docs, tes conversations de travail — et ne s'arrête pas à la recherche. Sa consolidation en fait une mémoire synthétisée du projet : son architecture, les décisions que tu as prises, et pourquoi.
Ce n'est pas un moteur de recherche qui te rend une ligne. Tu demandes « pourquoi on a choisi ça ? » et tu obtiens la synthèse — à travers des mois de travail, sans le bon mot-clé. Le tout en local : ton code ne quitte pas ta machine.
La règle
Trois surfaces. Elles ne sont pas interchangeables.
Transports différents, manifestes différents, bibliothèques différentes. La règle de routage tient en deux lignes, et c'est la première chose à lire :
Tu dessines des pixels dans Mnemosyne ? → Cartouche.
Tu es un processus séparé ? → App Layer 2 — ou MCP si l'appelant est un agent IA.
I
Cartouche
@mnemosyne_os/cartridge-sdk 0.1.0
Tu dessines des pixels DANS Mnemosyne.
Une iframe isolée qui parle à l'OS en postMessage. C'est la seule surface distribuable sur MnemoHub. Pas d'accès Node ni Electron : 86 actions hôte, dont 5 ouvertes sans permission.
Le SDK cartouche n'est PAS @mnemosyne_os/sdk. Installer le mauvais paquet est l'erreur n°1.
II
App Layer 2
@mnemosyne_os/sdk 1.4.1
Ton app est un processus séparé.
WebSocket JSON-RPC sur 127.0.0.1:7799, un JWT par app, liste d'origines autorisées. Tu déclares un manifeste, l'utilisateur accorde les droits dans une vraie fenêtre système, et tu interroges la mémoire.
L'OS doit tourner. Les pages web distantes sont refusées, par conception.
III
MCP
@mnemosyne_os/mcp 1.2.0
Ton appelant est un agent IA.
Claude Code, Claude Desktop, Cursor. Client léger sur le même 7799, huit outils : query, ask, ingest, vaults, résonances, ponts oniriques, position, git log. Zéro ligne de code à écrire.
Même contrainte : l'app Infinity doit être ouverte.
Démarrer
Le chemin le plus court, par surface.
MCP — zéro ligne de code
Infinity ouvert, Node 18+, puis dans le .mcp.json de ton projet :
{ "mcpServers": { "mnemosyne": {
"command": "npx",
"args": ["-y", "@mnemosyne_os/mcp"],
"env": { "MNEMO_DEFAULT_VAULT": "DEV" }
} } } App Layer 2
pnpm add @mnemosyne_os/sdk import { MnemoClientBrowser } from '@mnemosyne_os/sdk';
const client = await MnemoClientBrowser.connect(); // 127.0.0.1:7799
await client.register(MANIFEST); // l'utilisateur accorde, ou refuse
await client.ingest('Une note à retenir', 'NOTE', 'DEV');
const chronicles = await client.query('ma recherche', 'DEV', 10); Cartouche
Copie apps/mnemo-cartridge-boilerplate/, remplace la dépendance
workspace:* par la version npm, puis :
pnpm add @mnemosyne_os/cartridge-sdk
pnpm dev # vite, 127.0.0.1:5185
pnpm build # tsc && vite build -> dist/ Dans l'app : MnemoHub → Mes apps de dev → lie ton dossier. Le premier lien est gratuit ; le second exige une licence Engramm active — autant que tu l'apprennes ici plutôt qu'au milieu de ton intégration.
Le pacte
Ton app a exactement un coffre. Et elle ne peut pas en sortir.
Un vault par app, dérivé par le serveur, isolé de la recherche fédérée, invisible à la carte neurale et à l'état de rêve. Ton app ne peut pas élargir ses propres murs : ouvrir la permanence est une opération que le réseau n'atteint pas — seul l'utilisateur, dans son gestionnaire de coffres, le peut.
Ce n'est pas une politique, c'est une asymétrie de transport. Tu peux proposer. Tu ne peux pas graver. Si ça te paraît sévère : c'est exactement ce qui fait que ton utilisateur accepte d'installer ton app.
Les trois pièges qui coûtent une soirée
Silencieux
vault:write est porteur, et son absence ne dit rien. Sans lui
déclaré dans ton manifeste, ensureSandbox() est refusé
sans erreur visible — tu n'as simplement jamais de coffre. Le
boilerplate ne le déclare pas.
Irréversible
Renommer ton app orpheline son coffre. La propriété est indexée sur le
name du manifeste : le prochain ensure crée un
coffre neuf et abandonne l'ancien. Aucune migration n'existe.
À savoir
Le coffre n'existe qu'au premier lancement, jamais à
l'installation. Et toutes les cartouches partagent une origine : ne mets
aucun secret dans localStorage.
Bientôt · l'économie créateur
Une économie où le créateur garde la plus grosse part.
Quand l'économie du store ouvrira, la règle sera simple et publique : le développeur garde 80 % de chaque vente, le hub prend 15 %, et 5 % financent une DAO communautaire qui reverse au développement de l'écosystème. Pas de part cachée, pas de conditions qui bougent.
80 % développeur · 15 % hub · 5 % DAO communautaire
Le reste — comment ça marche, quand ça ouvre — arrive. Laisse ton email et sois le premier au courant. Zéro spam, juste l'annonce.
Open-core
Le SDK est ouvert. Le core est scellé. Et il a une date.
Disons-le dans le bon sens : les paquets avec lesquels tu construis — SDK, MCP, SDK cartouche — sont MIT, publiés, lisibles. Le moteur cognitif, lui, est propriétaire et livré scellé. Les clés, l'anti-piratage et le juridique restent privés.
Ce que ça veut dire pour toi, concrètement : tu n'as jamais besoin du core pour écrire une app. Le SDK est la frontière, et elle est stable.
Et la partie scellée ne le reste pas indéfiniment : sa licence bascule automatiquement en MIT le 1er janvier 2030. C'est écrit dans le fichier de licence, pas dans un billet de blog.
« La licence est une clé, pas un cadenas. »
Éditer le JSON à la main contourne le quota. On le sait, c'est accepté, et c'est la position open-core assumée : on ne se bat pas contre toi.
Le contrat
La mémoire perçoit, situe et révèle.
L'humain gouverne.
Pour toi, développeur, ça se traduit en une phrase : ton app peut proposer, l'utilisateur dispose. Elle n'efface rien en silence, elle ne mélange rien sans un geste humain, et elle ne sort de son coffre que si on l'y invite. Construis avec ça, pas contre.
Tu construis comment ?
L'offre développeur
Réserve ta licence offerte, et code ta première cartouche.
Tu construis sur Mnemosyne OS ? On ne veut pas ton argent, on veut ton retour. Télécharge l'OS, demande ta licence fondateur — offerte, et on t'ajoute 5 $ de crédits cloud pour tester tout de suite, sans même brancher ta clé API.
1
Télécharge l'OS
Gratuit, tout de suite. Windows, macOS ou Linux — l'OS complet, en local.
2
Demande ta licence offerte
Airdrop manuel — compte quelques jours. Elle débloque les fonctions et cartouches réservées, à vie, et arrive avec 5 $ de crédits cloud pour essayer sans clé API.
3
Scaffold ta première cartouche
Une commande, et tu interroges déjà le coffre sous FGAC.
npm create @mnemosyne_os/app Ou en vibe coding — colle ce prompt à ton assistant :
Prompt Construis une cartouche Mnemosyne OS : [décris ton app]. Avant de coder, lis lellms.txtà la racine de github.com/yaka0007/Mnemosyne-Neural-OS, puis clone une cartouche de référence MIT (MnemoReader) et lis sonsrc/. Utilise@mnemosyne_os/sdkpour ingérer et interroger le coffre sous FGAC — suis les patterns de la référence, ne devine pas l'API.