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

# Condicional

> Dirige la conversación por diferentes caminos según las respuestas o datos del usuario

El nodo **Condicional** funciona como un punto de decisión dentro de tu flujo: evalúa información que ya tienes del usuario y decide qué camino tomar. Piensa en él como una bifurcación en el camino — dependiendo de lo que responda o de los datos que tenga el usuario, la conversación seguirá una ruta u otra.

## Concepto clave: caminos y reglas

Antes de configurar, es importante entender dos conceptos:

* **Camino**: es una ruta que la conversación puede seguir. Cada camino tiene un nombre descriptivo y una o más reglas que deben cumplirse para que se active.
* **Regla**: es una condición individual que compara una variable con un valor. Por ejemplo: *"la edad del usuario es mayor o igual a 18"*.

<Note>
  Si un camino tiene **varias reglas**, **todas** deben cumplirse para que ese camino se active (lógica AND). Si necesitas que se active cuando **cualquiera** de las condiciones se cumpla, crea **caminos separados** para cada una.
</Note>

### Camino por defecto: "Si no"

Todo nodo Condicional incluye automáticamente un camino llamado **"Si no"** (fallback). Este camino se activa cuando **ninguno** de los otros caminos se cumple. Es tu red de seguridad para garantizar que la conversación siempre tenga un camino a seguir.

***

## Configuración paso a paso

<Steps>
  <Step title="Crea un nuevo camino">
    Haz clic en **"Nuevo camino"** para agregar tu primera condición. Asígnale un nombre descriptivo que te ayude a identificar rápidamente qué evalúa (por ejemplo: "Mayor de edad", "Cliente premium", "Horario laboral").
  </Step>

  <Step title="Configura la primera regla">
    Cada regla tiene tres partes:

    1. **Variable** — el dato que quieres evaluar (por ejemplo, `{{$memory.edad}}`)
    2. **Operador** — cómo quieres comparar ese dato (por ejemplo, "Mayor o igual")
    3. **Valor** — contra qué lo comparas (por ejemplo, `18`)
  </Step>

  <Step title="Agrega más reglas si es necesario">
    Si necesitas que varias condiciones se cumplan al mismo tiempo, haz clic en **"+"** dentro del mismo camino para agregar reglas adicionales. Todas las reglas dentro de un camino se evalúan con lógica **AND** (todas deben ser verdaderas).
  </Step>

  <Step title="Crea caminos adicionales">
    Repite el proceso para cada ruta alternativa que necesites. Cada camino se evalúa en orden: el primero que se cumpla será el que se ejecute.
  </Step>

  <Step title="Conecta los nodos siguientes">
    Cada camino (incluyendo "Si no") tiene un punto de conexión a la derecha. Arrastra una línea desde cada punto hacia el nodo que debe ejecutarse en esa ruta.
  </Step>
</Steps>

***

## Operadores disponibles

Los operadores definen **cómo** se compara la variable con el valor. Se organizan en cuatro categorías:

### Comparación de igualdad

| Operador     | Descripción                   | Ejemplo                                     |
| :----------- | :---------------------------- | :------------------------------------------ |
| **Igual**    | El valor es exactamente igual | `{{$memory.status}}` igual a `activo`       |
| **No igual** | El valor es diferente         | `{{$memory.status}}` no igual a `cancelado` |

### Comparación numérica

| Operador          | Descripción                     | Ejemplo                                    |
| :---------------- | :------------------------------ | :----------------------------------------- |
| **Mayor**         | El valor es estrictamente mayor | `{{$memory.edad}}` mayor que `18`          |
| **Mayor o igual** | El valor es mayor o igual       | `{{$memory.puntaje}}` mayor o igual a `70` |
| **Menor**         | El valor es estrictamente menor | `{{$memory.intentos}}` menor que `3`       |
| **Menor o igual** | El valor es menor o igual       | `{{$memory.deuda}}` menor o igual a `0`    |

### Búsqueda en texto

| Operador           | Descripción                            | Ejemplo                                      |
| :----------------- | :------------------------------------- | :------------------------------------------- |
| **Contiene**       | El texto incluye la palabra o frase    | `{{$message.text}}` contiene `ayuda`         |
| **No contiene**    | El texto no incluye la palabra o frase | `{{$message.text}}` no contiene `cancelar`   |
| **Empieza con**    | El texto comienza con el valor         | `{{$user.email}}` empieza con `admin`        |
| **No empieza con** | El texto no comienza con el valor      | `{{$user.phone}}` no empieza con `+593`      |
| **Termina con**    | El texto termina con el valor          | `{{$user.email}}` termina con `@empresa.com` |

### Validación de tipo (Es / No es)

Los operadores **Es** y **No es** permiten verificar si una variable corresponde a un tipo de dato específico. En lugar de escribir un valor, seleccionas el tipo desde una lista:

| Tipo             | Qué valida                       |
| :--------------- | :------------------------------- |
| **Alfanumérico** | Letras y números combinados      |
| **Alfabético**   | Solo letras                      |
| **Nombre(s)**    | Formato de nombre de persona     |
| **Número**       | Solo valores numéricos           |
| **Email**        | Formato de correo electrónico    |
| **Cédula**       | Número de documento de identidad |
| **URL**          | Formato de enlace web            |
| **Fecha**        | Formato de fecha                 |
| **Imagen**       | Archivo de imagen                |
| **RUC**          | Registro Único de Contribuyente  |
| **Ubicación**    | Coordenadas o dirección          |

**Ejemplo**: `{{$memory.correo}}` **Es** → **Email** verifica que lo que escribió el usuario tenga formato de correo electrónico.

### Verificación de vacío

| Operador     | Descripción                         | Ejemplo                            |
| :----------- | :---------------------------------- | :--------------------------------- |
| **Vacío**    | La variable no tiene valor asignado | `{{$memory.nombre}}` está vacío    |
| **No vacío** | La variable tiene algún valor       | `{{$memory.nombre}}` no está vacío |

<Note>
  Los operadores **Vacío** y **No vacío** no requieren un valor de comparación — solo evalúan si la variable tiene o no contenido.
</Note>

### Expresiones regulares (Regex)

| Operador            | Descripción                     | Ejemplo                                    |
| :------------------ | :------------------------------ | :----------------------------------------- |
| **Regex match**     | Coincide con el patrón regex    | `{{$message.text}}` regex match `^\d{10}$` |
| **Regex not match** | No coincide con el patrón regex | `{{$message.text}}` regex not match `[<>]` |

<Warning>
  Las expresiones regulares son una herramienta avanzada. Si no estás familiarizado con regex, los demás operadores cubren la mayoría de los escenarios comunes.
</Warning>

***

## Lógica de evaluación

El nodo Condicional evalúa los caminos **de arriba hacia abajo**, en el orden en que aparecen en el panel. El primer camino cuyas reglas se cumplan será el que se ejecute.

```
¿Se cumple Camino 1?
  └─ Sí → Ejecuta la ruta del Camino 1
  └─ No → ¿Se cumple Camino 2?
            └─ Sí → Ejecuta la ruta del Camino 2
            └─ No → ¿Se cumple Camino 3?
                      └─ Sí → Ejecuta la ruta del Camino 3
                      └─ No → Ejecuta la ruta "Si no" (fallback)
```

<Note>
  Puedes **reordenar los caminos** arrastrándolos con el ícono de agarre (⠿) que aparece a la izquierda de cada camino. Esto es importante porque el orden afecta cuál se evalúa primero.
</Note>

### Lógica AND vs OR

| Lo que necesitas                                  | Cómo configurarlo                                  |
| :------------------------------------------------ | :------------------------------------------------- |
| Que se cumplan **todas** las condiciones a la vez | Agrega varias reglas **dentro del mismo camino**   |
| Que se cumpla **cualquiera** de las condiciones   | Crea **caminos separados**, uno por cada condición |

***

## Modos de vista

El panel de configuración ofrece dos modos de visualización que puedes alternar con el botón de vista en la esquina superior:

* **Vista expandida**: muestra cada regla como una tarjeta con etiquetas descriptivas (Variable, Operador, Valor). Ideal cuando estás configurando condiciones por primera vez.
* **Vista compacta**: muestra cada regla en una sola línea horizontal. Ideal cuando ya conoces las condiciones y quieres una vista más rápida del conjunto.

***

## Ejemplos prácticos

### Verificación de edad

Un flujo que necesita verificar si el usuario es mayor de edad:

| Camino        | Regla | Variable           | Operador      | Valor |
| :------------ | :---- | :----------------- | :------------ | :---- |
| Mayor de edad | 1     | `{{$memory.edad}}` | Mayor o igual | `18`  |
| **Si no**     | —     | —                  | —             | —     |

El camino "Mayor de edad" se activa si la edad es 18 o más. Cualquier otro caso sigue por "Si no".

### Enrutamiento por país y tipo de cliente

Un flujo que dirige a clientes premium de Colombia a un flujo especial:

| Camino           | Regla | Variable                   | Operador | Valor      |
| :--------------- | :---- | :------------------------- | :------- | :--------- |
| Premium Colombia | 1     | `{{$user.country}}`        | Igual    | `Colombia` |
|                  | 2     | `{{$memory.tipo_cliente}}` | Igual    | `premium`  |
| Colombia regular | 1     | `{{$user.country}}`        | Igual    | `Colombia` |
| **Si no**        | —     | —                          | —        | —          |

En "Premium Colombia", **ambas** reglas deben cumplirse (AND): el país debe ser Colombia **y** el tipo de cliente debe ser premium. Si solo se cumple la primera, el flujo pasa a evaluar "Colombia regular".

### Validación de formato de entrada

Un flujo que valida si el usuario ingresó un correo electrónico:

| Camino       | Regla | Variable             | Operador | Tipo  |
| :----------- | :---- | :------------------- | :------- | :---- |
| Email válido | 1     | `{{$memory.correo}}` | Es       | Email |
| **Si no**    | —     | —                    | —        | —     |

Si el dato tiene formato de correo, sigue por "Email válido". Si no, puedes usar el camino "Si no" para pedir al usuario que lo ingrese nuevamente.

### Detección de intención con texto

Un flujo que detecta palabras clave en el mensaje del usuario:

| Camino          | Regla | Variable            | Operador | Valor      |
| :-------------- | :---- | :------------------ | :------- | :--------- |
| Quiere cancelar | 1     | `{{$message.text}}` | Contiene | `cancelar` |
| Quiere ayuda    | 1     | `{{$message.text}}` | Contiene | `ayuda`    |
| Saludo          | 1     | `{{$message.text}}` | Contiene | `hola`     |
| **Si no**       | —     | —                   | —        | —          |

Cada camino es independiente (lógica OR): si el mensaje contiene "cancelar", sigue la primera ruta; si contiene "ayuda", la segunda, y así sucesivamente.