Saltar al contenido principal

Tu primer cartucho

Un cartucho es una app web en una ventana del canvas de Mnemosyne, con tu memoria como backend. De la carpeta vacía al cartucho en marcha, con un agente de IA tecleando por ti.

Lo que necesitas​

  1. Mnemosyne OS, abierto. Posee las bóvedas y la pasarela local. Descárgalo si aún no lo has hecho.
  2. Node.js 18 o superior.
  3. Un agente de código: Claude Code, Cursor, Copilot, el que uses.

Paso 1: dale tu memoria a tu agente​

Opcional, y cambia todo lo demás. Conecta tu agente por MCP y leerá las decisiones, las notas y el código que ya escribiste mientras construye.

Un bloque de config por cliente: Conectar Claude a Mnemosyne.

consejo

MNEMO_VAULTS nombra las bóvedas que el agente puede ver. Nada más es alcanzable, y las bóvedas con protección Máxima conservan sus garantías.

Paso 2: el prompt de entorno​

Abre una terminal en una carpeta vacía, lanza tu agente ahí y pega esto.

Prepárame un proyecto de cartucho para Mnemosyne OS.

1. Comprueba que Node.js sea 18 o superior. Detente y dímelo si no lo es.
2. Genera el boilerplate oficial en una carpeta my-cartridge:
   npx degit Mnemosyne-OS/Mnemosyne-Neural-OS/examples/cartridge-boilerplate my-cartridge
3. Desde esa carpeta, instala y luego actualiza el SDK. La plantilla fija un
   rango antiguo a propósito, así que el segundo comando importa:
   npm install
   npm install @mnemosyne_os/cartridge-sdk@latest
4. Lee AGENTS.md en la raíz del scaffold, entero, antes que nada. Es la
   superficie de build que manda: forma del manifest, vocabulario de permisos y
   la lista completa de acciones del host. Nunca inventes una acción o una API
   que no esté ahí. Si una capacidad falta en esa lista, no existe: dilo.
5. Renombra la app. En mnemo-plugin.json Y package.json, pon "name" a
   @mi-alias/mi-cartucho. Los dos archivos deben coincidir.
6. Ejecuta npm run build y confirma que pasa.
7. Ejecuta npm run dev y déjalo sirviendo en 127.0.0.1:5185.

Después detente y dime qué hiciste. No escribas todavía nada de código
funcional.

Obtienes un cartucho que funciona: reclama su propia bóveda, escribe y relee memoria, llama al modelo del host y abre un diálogo de carpeta nativo.

Elige el nombre una sola vez

La propiedad de la bóveda se indexa sobre el name del manifest. Cámbialo más tarde y el siguiente arranque crea una bóveda nueva y abandona la anterior, con todo lo que contiene.

Paso 3: vincúlalo en la app​

MnemoHub → Mis apps → Panel DEV → Mis cartuchos dev → «Vincular un cartucho local», y elige tu carpeta my-cartridge.

El manifest apunta a tu servidor Vite, así que tienes hot reload dentro de la ventana de Mnemosyne.

El primer cartucho vinculado es gratis. Las siguientes ranuras requieren una licencia Engramm activa.

Paso 4: el prompt de construcción​

De vuelta en tu agente, dentro de la carpeta del proyecto:

Construye mi cartucho en esta carpeta.

Lo que hace: <describe tu app en unas frases>.

Reglas:
- Lee AGENTS.md entero primero. Cada llamada al host es
  await sdk.invoke('<action>', payload), y su tabla de acciones es la única
  lista de acciones que existe. No adivines APIs.
- Declara el MÍNIMO de permisos en mnemo-plugin.json. Pedir de más hace que un
  cartucho se rechace en la revisión, y vault:write está marcado como sensible.
- Reclama la bóveda sandbox una vez al arrancar, antes de cualquier escritura:
  const { vault } = await sdk.ensureSandbox();
  Después apunta siempre a esa bóveda por su nombre.
- La primera llamada que necesite un permiso abre un diálogo nativo y espera mi
  clic. Deja la secuencia de arranque repetible y pon un botón Reintentar junto
  al error.
- Llama a onHostConfig() una vez al inicio y estiliza todo con las variables CSS
  del host (--bg-void, --bg-surface, --text-primary, --accent). El cartucho
  seguirá entonces mi tema y mi color de acento.
- Deja src/sdk/mnemo-sdk.ts como simple reexport. Nunca reimplementes el
  transporte postMessage.
- Ejecuta npm run build al terminar y corrige lo que reporte.

Las trampas​

  • La primera llamada protegida espera a un humano. El host abre su diálogo de autorización nativo en la primera llamada que necesita un permiso, y el tiempo de espera del SDK es de cinco minutos por eso. Deja la secuencia de arranque repetible: las concesiones persisten, y una respuesta tardía se recupera volviendo a llamar.
  • vault:write lo sostiene todo. Sin él en el manifest, ensureSandbox(), describeVaultTile() y socialIngest() se rechazan al instante, sin ningún diálogo. Quítalo si nunca escribes memoria.
  • Los cartuchos comparten origen. Todos cargan desde mnemo-plugin://app/<id>, así que localStorage e IndexedDB no están aislados entre cartuchos instalados. Guarda el estado en tu bóveda.
  • Los permisos son más amplios de lo que parecen. Un solo vault:write desbloquea también instalar y desinstalar plugins, crear bóvedas, borrar conversaciones y DocWatch. dialog:open concede lectura y escritura de los tipos de archivo permitidos en cualquier punto de la carpeta personal.
  • La bóveda existe en el primer lanzamiento, nunca en la instalación.

Paso 5: publicar​

La tienda es una vía. La otra es pasar tu enlace de repositorio, que se instala directamente en la app de esa persona: ver Comparte tu app.

Cuatro cosas que verifica el preflight de la tienda:

  1. entrypoints.renderer pasa a "index.html", relativo. El valor de desarrollo es http://localhost:5185/index.html, que el preflight rechaza.
  2. Commitea dist/. El protocolo mnemo-plugin:// sirve dist/<archivo> primero, y ningún build corre en la máquina del usuario.
  3. Mantén base: './' en vite.config.ts. Una ruta absoluta /assets/… da 404 bajo el protocolo personalizado.
  4. Manifest en la raíz del repo, con su name igual al id de app enviado, y un campo repository en package.json.

Aloja el repo en github.com, gitlab.com o bitbucket.org.

Después pulsa «Publicar» en tu cartucho vinculado. El formulario de envío se rellena desde tu manifest, y lo firmas con tu monedero soberano. Publicar requiere una licencia Engramm activa.

La revisión es manual y la guarda el fundador. Cuenta con un humano, y con una espera.

Sobre el dinero

Hoy no hay pagos, ni compras integradas, ni reparto de ingresos cableado. La pantalla de economía de la tienda es un anuncio.

Sigue por aquí​