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

# Context

> Variáveis de contexto: dados temporários da execução atual e variáveis do sistema

Você usa o contexto para armazenar variáveis que persistem apenas durante a execução atual — ou seja, elas só existem dentro do fluxo específico onde você as cria. Se precisar armazenar dados que durem até 24 horas, use a [Memory](/pt/guias/variaveis/memory).

Pense no contexto como um quadro branco temporário: toda vez que um usuário inicia uma conversa, você recebe um quadro branco limpo e novo. Tudo o que você escreve nele está disponível para todos os nós do fluxo, mas quando a conversa termina, o quadro é apagado.

## Variáveis do sistema

Quando uma execução começa, o Brain Studio injeta automaticamente variáveis do sistema no contexto. Você pode acessá-las em todos os nós sem precisar declará-las.

### executionId

Cada execução de fluxo recebe um identificador único chamado `executionId`. O Brain Studio o gera automaticamente quando o fluxo inicia e ele permanece constante durante toda a execução, incluindo ramificações entre Workflows e chamadas a ferramentas.

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

<Note>
  O `executionId` é somente leitura. O Brain Studio o gera automaticamente no início de cada execução; você não precisa criá-lo nem modificá-lo.
</Note>

#### Para que serve

O `executionId` permite identificar de forma única cada execução do seu fluxo. Isso é útil quando você precisa:

* **Conectar sistemas externos**: Enviar o ID para seu backend para que ele possa rastrear ou correlacionar a conversa com seus registros internos.
* **Retomar execuções pausadas**: Quando um Agente de IA pausa esperando uma resposta externa (por exemplo, uma aprovação), o sistema externo precisa do `executionId` para retomar a execução correta.
* **Auditoria e rastreabilidade**: Registrar nos seus bancos de dados qual execução gerou cada ação, facilitando o rastreamento e a solução de problemas.

#### Exemplo: Enviando para uma API externa

Suponha que seu fluxo consulte um serviço externo e você precise que esse serviço saiba qual execução deve responder. Em um nó de **API**, você pode incluir o `executionId` no corpo da requisição:

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

Seu serviço externo recebe o `callbackExecutionId` e o usa para enviar a resposta de volta à execução correta.

#### Exemplo: Retomando um Agente de IA pausado

Quando você configura um Agente de IA com **pausa para retomada externa**, o payload de retomada requer o `executionId` para identificar qual execução continuar:

```json theme={null}
{
  "executionId": "{{$context.executionId}}",
  "message": "Payment approved successfully",
  "pauseInteraction": false
}
```

#### Exemplo: Salvando no Datum para auditoria

Em um nó do **Datum**, você pode salvar o `executionId` junto com os dados da operação para ter rastreabilidade completa:

```json theme={null}
{
  "user": "{{$user.name}}",
  "action": "credit_request",
  "executionId": "{{$context.executionId}}",
  "date": "{{$context.currentDate}}"
}
```

Assim, se você precisar investigar o que aconteceu em uma conversa específica, pode pesquisar por `executionId` no seu banco de dados e ver exatamente quais etapas foram executadas.

#### Em nós de código

Dentro de um nó de **Code**, você acessa o `executionId` como qualquer outra variável de contexto:

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

$output.set('log', `Processing execution: ${executionId}`)
```

## Variáveis personalizadas

Além das variáveis do sistema, você pode criar suas próprias variáveis de contexto usando nós de **Variable**, nós de **Code** ou qualquer nó que salve dados no contexto (como respostas de nós interativos).

### Lendo variáveis

Dentro de qualquer nó você pode acessar o contexto com a sintaxe `{{$context.variableName}}`. Por exemplo, se as variáveis no contexto forem:

```json theme={null}
{
  "name": "John",
  "lastOrder": { "id": "ORD-123", "status": "on the way" }
}
```

Então:

* `{{$context.name}}` mostra `John`.
* `{{$context.lastOrder.status}}` mostra `on the way`.

### Context em nós de código

Nos nós de código, você usa os métodos do contexto de forma diferente:

* `$context.get(key, [defaultValue])` — Obtém um valor do contexto
* `$context.set(key, value)` — Salva ou atualiza um valor no contexto
* `$context.getHttpResponse(key)` — Obtém a resposta completa de um nó HTTP
* `$context.getHttpRequest(key)` — Obtém a requisição enviada por um nó HTTP

Para obter variáveis do contexto:

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

const name = $context.get('name', 'John')
```

Para salvar variáveis dentro de um nó de código:

```js theme={null}
$context.set('lastOrder.status', 'delivered')

const user = { name: 'John', plan: 'gold' }
$context.set('user', user)

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

<Tip>
  Você pode usar notação de ponto para acessar chaves aninhadas no contexto. Por exemplo, `$context.get('lastOrder.status')` retorna `"on the way"` sem precisar recuperar o objeto inteiro.
</Tip>

## Context vs Memory

| Característica           | Context (`$context`)                     | Memory (`$memory`)                  |
| ------------------------ | ---------------------------------------- | ----------------------------------- |
| **Duração**              | Apenas durante a execução atual          | Até 24 horas                        |
| **Escopo**               | Todos os nós do fluxo                    | Todos os workflows do usuário       |
| **Uso típico**           | Dados temporários da conversa            | Dados que persistem entre conversas |
| **Variáveis do sistema** | `executionId` (injetado automaticamente) | Nenhuma                             |

<Tip>
  Se você não tiver certeza se deve usar context ou memory, pergunte a si mesmo: **preciso desses dados depois que a conversa terminar?** Se sim, use a [Memory](/pt/guias/variaveis/memory). Se só precisar durante a conversa atual, use o Context.
</Tip>