> ## Documentation Index
> Fetch the complete documentation index at: https://docs.jelou.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Memory

> Persiste datos entre conversaciones con control de tiempo de vida (TTL) y soporte para archivos

## Introducción

Memory te permite guardar variables que persisten entre conversaciones, workflows y nodos. A diferencia de Context (que solo está disponible durante la conversación actual), Memory mantiene los datos disponibles para futuras interacciones con el usuario.

## Características principales

| Característica                 | Descripción                                             |
| ------------------------------ | ------------------------------------------------------- |
| **TTL configurable**           | Define el tiempo de vida de cada variable en segundos   |
| **Múltiples tipos**            | Soporta primitivos, JSON y archivos                     |
| **Almacenamiento de archivos** | Guarda imágenes, videos, audios y documentos hasta 10MB |
| **Métodos específicos**        | API diferenciada para cada tipo de dato                 |

## Tipos de datos

| Tipo        | Tamaño máximo  | TTL       | TTL máximo          |
| ----------- | -------------- | --------- | ------------------- |
| **String**  | 255 caracteres | Opcional  | -                   |
| **Number**  | 15 dígitos     | Opcional  | -                   |
| **Boolean** | -              | Opcional  | -                   |
| **JSON**    | 15KB           | Requerido | 86.400s (1 día)     |
| **File**    | 10MB           | Requerido | 604.800s (1 semana) |

<Note>
  **TTL (Time To Live):** Tiempo de vida en segundos. Transcurrido el TTL, la variable se elimina automáticamente. Por ejemplo, `3600` = 1 hora, `86400` = 1 día.
</Note>

## Guardar variables

### Usando el nodo Variable

Para guardar variables sin código, usa el nodo **Variable** dentro de la sección `Lógica`. En `Variable` coloca el nombre y en `Valor` lo que quieres guardar; puede ser texto plano, otra variable o un dato del contexto.

```md theme={null}
Variable: nombre
Valor: {{$user.names}}
```

<Tip>
  El nodo Variable es ideal para guardar primitivos (string, number, boolean) de forma rápida y visual.
</Tip>

<Note>
  Cada nodo Variable permite un máximo de **20 variables**. Si necesitas más, usa varios nodos o guarda los valores desde un nodo de código.
</Note>

### Usando nodos de código

Para mayor control sobre TTL y tipos de datos complejos, usa los métodos de `$memory` en nodos de código:

```javascript theme={null}
// Primitivos (string, number, boolean) - TTL opcional
$memory.set('nombre', 'Juan')
$memory.set('intentos', 3)
$memory.set('verificado', true)

// Primitivo con TTL (expira en 1 hora)
$memory.set('codigoTemporal', 'ABC123', 3600)

// JSON - TTL requerido (máximo 1 día)
$memory.setJson('preferencias', {
  idioma: 'es',
  notificaciones: true
}, 86400)

// Archivo - async, TTL requerido, MIME requerido (máximo 1 semana)
await $memory.setFile('comprobante', base64String, 604800, 'application/pdf')
```

## Leer variables

### En cualquier nodo

Dentro de cualquier nodo puedes acceder a Memory con la sintaxis `{{$memory.nombreVariable}}`. Por ejemplo, si las variables en memoria son:

```json theme={null}
{
  "nombre": "Juan",
  "ultimoPedido": { "id": "PED-123", "estado": "en camino" }
}
```

Entonces:

* `{{$memory.nombre}}` muestra `Juan`
* `{{$memory.ultimoPedido.estado}}` muestra `en camino`

### En nodos de código

Usa los métodos específicos según el tipo de dato:

```javascript theme={null}
// Primitivos
const nombre = $memory.get('nombre')
const nombre = $memory.get('nombre', 'Invitado') // con valor por defecto

// JSON
const prefs = $memory.getJson('preferencias')
const prefs = $memory.getJson('preferencias', {}) // con valor por defecto

// Archivos - devuelve FileHandle
const archivo = $memory.getFile('comprobante')
```

## Trabajar con archivos

Al guardar un archivo en Memory, debes proporcionar el contenido en base64, el TTL y el tipo MIME:

```javascript theme={null}
// Guardar un archivo
await $memory.setFile('documento', base64Content, 604800, 'application/pdf')
```

Al leer un archivo con `$memory.getFile()` obtienes un **FileHandle** con tres métodos para acceder al contenido:

| Método        | Descripción                      | Async |
| ------------- | -------------------------------- | ----- |
| `.toUrl()`    | URL temporal para descargar (S3) | No    |
| `.toBase64()` | Contenido en string base-64      | Sí    |
| `.toRaw()`    | Buffer / Uint8Array              | Sí    |

```javascript theme={null}
// Obtener URL temporal
const url = $memory.getFile('comprobante').toUrl()

// Obtener contenido en base64
const base64 = await $memory.getFile('comprobante').toBase64()

// Obtener contenido del archivo
const contenido = await $memory.getFile('comprobante').toRaw()
```

### Tipos MIME permitidos

| Categoría      | Tipos MIME                                                              |
| -------------- | ----------------------------------------------------------------------- |
| **Texto**      | `text/plain`                                                            |
| **JSON**       | `application/json`                                                      |
| **XML**        | `application/xml`, `text/xml`                                           |
| **Imágenes**   | `image/jpeg`, `image/png`, `image/gif`                                  |
| **Videos**     | `video/mp4`, `video/ogg`, `video/webm`, `video/x-msvideo`, `video/mpeg` |
| **Audios**     | `audio/mpeg`, `audio/wav`, `audio/ogg`, `audio/aac`, `audio/flac`       |
| **Documentos** | `application/pdf`                                                       |

<Warning>
  Los métodos `$memory.setFile()`, `$memory.getFile().toBase64()` y `$memory.getFile().toRaw()` son **asincrónicos**. Debes usar `await` al llamarlos.
</Warning>

## Eliminar variables

Puedes eliminar variables antes de que expire su TTL:

```javascript theme={null}
// Eliminar una variable
$memory.delete('temporal')

// Eliminar múltiples variables
$memory.delete(['cache', 'sesion', 'temporal'])
```

## Seguridad

<Warning>
  **No almacenes datos sensibles en Memory:**

  * Contraseñas o números de tarjeta de crédito
  * Tokens de autenticación de larga duración
  * Información de identificación personal (PII) altamente sensible

  Para persistencia a largo plazo, usa **[Datum](/guides/nodos/datum)**.
</Warning>