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

# Contexto

> Variables de contexto: datos temporales de la ejecución actual y variables del sistema

Usas el contexto para guardar variables que persisten únicamente durante la ejecución actual, es decir, solo viven dentro del flujo específico donde las creas. Si necesitas guardar datos que duren hasta 24 horas, usa la [Memoria](/guides/variables/memory).

Piensa en el contexto como una pizarra temporal: cada vez que un usuario inicia una conversación, obtienes una pizarra nueva y limpia. Todo lo que escribas en ella está disponible para todos los nodos del flujo, pero cuando la conversación termina, la pizarra se borra.

## Variables del sistema

Al iniciar una ejecución, Brain Studio inyecta automáticamente variables del sistema en el contexto. Puedes acceder a ellas en todos los nodos sin necesidad de declararlas.

### executionId

Cada ejecución de un workflow recibe un identificador único llamado `executionId`. Brain Studio lo genera automáticamente al iniciar el flujo y permanece constante durante toda la ejecución, incluyendo derivaciones entre Workflows y llamadas a Tools.

```
{{$context.executionId}}
```

<Note>
  El `executionId` es de solo lectura. Brain Studio lo genera automáticamente al iniciar cada ejecución; no necesitas crearlo ni modificarlo.
</Note>

#### Para qué sirve

El `executionId` te permite identificar de forma única cada ejecución de tu flujo. Esto es útil cuando necesitas:

* **Conectar sistemas externos**: Enviar el ID a tu backend para que pueda rastrear o correlacionar la conversación con tus registros internos.
* **Reanudar ejecuciones pausadas**: Cuando un AI Agent se pausa esperando una respuesta externa (por ejemplo, una aprobación), el sistema externo necesita el `executionId` para reanudar la ejecución correcta.
* **Auditoría y trazabilidad**: Registrar en tus bases de datos qué ejecución generó cada acción, facilitando el seguimiento y la resolución de problemas.

#### Ejemplo: Enviar a una API externa

Supongamos que tu flujo consulta un servicio externo y necesitas que ese servicio sepa a qué ejecución responder. En un nodo **API**, puedes incluir el `executionId` en el cuerpo de la petición:

```json theme={null}
{
  "orderId": "{{$context.orderId}}",
  "callbackExecutionId": "{{$context.executionId}}",
  "action": "procesar_pago"
}
```

Tu servicio externo recibe el `callbackExecutionId` y lo usa para enviar la respuesta de vuelta a la ejecución correcta.

#### Ejemplo: Reanudar un AI Agent pausado

Cuando configuras un AI Agent con **pausa por reanudación externa**, el payload de reanudación requiere el `executionId` para identificar qué ejecución continuar:

```json theme={null}
{
  "executionId": "{{$context.executionId}}",
  "message": "Pago aprobado exitosamente",
  "pauseInteraction": false
}
```

#### Ejemplo: Guardar en Datum para auditoría

En un nodo **Datum**, puedes guardar el `executionId` junto con los datos de la operación para tener trazabilidad completa:

```json theme={null}
{
  "usuario": "{{$user.name}}",
  "accion": "solicitud_credito",
  "executionId": "{{$context.executionId}}",
  "fecha": "{{$context.currentDate}}"
}
```

Así, si necesitas investigar qué pasó en una conversación específica, puedes buscar por `executionId` en tu base de datos y ver exactamente los pasos que se ejecutaron.

#### En nodos de código

Dentro de un nodo **Código**, accedes al `executionId` igual que a cualquier otra variable de contexto:

```js theme={null}
const executionId = $context.get('executionId')

$output.set('log', `Procesando ejecución: ${executionId}`)
```

## Variables personalizadas

Además de las variables del sistema, puedes crear tus propias variables de contexto usando nodos de **Variable**, nodos de **Código**, o cualquier nodo que guarde datos en contexto (como las respuestas de nodos interactivos).

### Leer variables

Dentro de cualquier nodo puedes acceder al contexto con la sintaxis `{{$context.nombreVariable}}`. Por ejemplo, si las variables en contexto son:

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

Entonces:

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

### Contexto en nodos de código

En los nodos de código, usas los métodos de contexto de forma diferente:

* `$context.get(key, [defaultValue])` — Obtiene un valor del contexto
* `$context.set(key, value)` — Guarda o actualiza un valor en el contexto
* `$context.getHttpResponse(key)` — Obtiene la respuesta completa de un nodo HTTP
* `$context.getHttpRequest(key)` — Obtiene la petición enviada por un nodo HTTP

Para obtener variables de contexto:

```js theme={null}
const nombre = $context.get('nombre')

const nombre = $context.get('nombre', 'Juan')
```

Para guardar variables dentro de un nodo código:

```js theme={null}
$context.set('ultimoPedido.estado', 'entregado')

const usuario = { nombre: 'Juan', plan: 'gold' }
$context.set('usuario', usuario)

const pedidos = ['PED-123', 'PED-456']
$context.set('pedidos', pedidos)
```

<Tip>
  Puedes usar la sintaxis de objetos con el punto para acceder a llaves internas del contexto. Por ejemplo, `$context.get('ultimoPedido.estado')` devuelve `"en camino"` sin necesidad de obtener todo el objeto.
</Tip>

## Contexto vs Memoria

| Característica            | Contexto (`$context`)                     | Memoria (`$memory`)                      |
| ------------------------- | ----------------------------------------- | ---------------------------------------- |
| **Duración**              | Solo la ejecución actual                  | Hasta 24 horas                           |
| **Alcance**               | Todos los nodos del flujo                 | Todos los workflows del usuario          |
| **Uso típico**            | Datos temporales de la conversación       | Datos que persisten entre conversaciones |
| **Variables del sistema** | `executionId` (inyectado automáticamente) | No tiene                                 |

<Tip>
  Si dudas entre contexto y memoria, hazte esta pregunta: **¿necesito este dato después de que termine la conversación?** Si la respuesta es sí, usa [Memoria](/guides/variables/memory). Si solo lo necesitas durante la conversación actual, usa Contexto.
</Tip>