> For the complete documentation index, see [llms.txt](https://prometheo.gitbook.io/prometheo/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://prometheo.gitbook.io/prometheo/integraciones/prometheo-connect.md).
# Prometheo Connect
### 1️⃣ ¿Qué es Prometheo Connect? (en simple)
Prometheo Connect es la funcionalidad que te permite **conectar tu asistente con otros sistemas usando sus APIs**.
Dicho en criollo:\
le das a tu asistente **“enchufes”** para que pueda:
* 🔍 **Consultar información** en otros sistemas\
(stock, precios, disponibilidad, estados, etc.)
* ✍️ **Crear cosas** en otros sistemas\
(reservas, pedidos, turnos, leads, emisiones, etc.)
👉 Vos **no programás**, solo configurás formularios.\
👉 Pero **alguien tiene que entender la API externa** (documentación técnica).
***
### 2️⃣ ¿Para qué sirve? (casos reales)
Prometheo Connect se usa cuando necesitás **datos en tiempo real** o **acciones reales**.
Ejemplos típicos:
* Consultar stock o disponibilidad actual.
* Traer precios siempre actualizados.
* Crear reservas o turnos.
* Generar pedidos u órdenes.
* Consultar estado de compra, ticket o envío.
* Confirmar pagos o transacciones.
📌 El flujo siempre es:
> Usuario escribe → asistente pregunta → API responde → asistente explica en humano.
***
### 3️⃣ Cómo se usa dentro de Prometheo (paso a paso)
#### Paso 1: Crear un endpoint en Prometheo Connect
Desde **Prometheo Connect**:
1. Hacés clic en **"+Crear endpoint"**
1. Completás los datos básicos:
**Nombre (ID interno)**\
Sin espacios, claro y corto.\
Ejemplos:
* `consultar_stock`
* `crear_reserva`
* `buscar_vuelos`
**Descripción**\
Solo para humanos:
* “Consulta stock por código de producto”
* “Crea una reserva en el sistema de turnos”
**Método HTTP**
* `GET` → para consultar datos
* `POST` → para crear algo (lo más común)
**URL**\
La que indica la documentación de la API externa.
***
#### Headers (muy importante)
Acá van cosas como:
* `Content-Type: application/json`
* `Authorization: Bearer API_KEY`
👉 Esto **no lo inventás**:\
lo copiás de la documentación o te lo pasa el proveedor técnico.
***
#### Body (si el endpoint lo necesita)
Usualmente en formato JSON (para POST).
Ejemplo conceptual:
```json
{
"producto_id": "",
"cantidad": "",
"email_cliente": ""
}
```
No necesitás saber programar, pero sí:
* qué campos pide la API
* cómo se llaman exactamente
***
#### Probar el endpoint
Desde la pestaña **Test**:
* Si responde `200` o `201`: ✅ OK
* Si responde `400 / 401 / 403 / 405`:\
suele ser:
* permisos,
* headers mal puestos,
* método incorrecto,
* body mal armado.
👉 Acá normalmente entra alguien técnico.
***
#### Guardar el endpoint
Una vez que responde bien, lo guardás.\
Ese endpoint queda listo para que el asistente lo use.
***
### 4️⃣ Paso 2: validar antes de usarlo con clientes
Antes de soltarlo en producción:
* Probá distintos casos.
* Confirmá que la respuesta trae **los datos que necesitás**.
* Verificá que:
* haya stock,
* precios,
* IDs,
* estados claros.
👉 El asistente **solo puede explicar lo que la API devuelve**.
***
### 5️⃣ Paso 3: usar el endpoint desde el asistente
Una vez creado:
* El endpoint se convierte en una **herramienta** del asistente.
En la conversación, el asistente:
1. Le pide datos al usuario.
2. Ejecuta el endpoint con esos datos.
3. Lee la respuesta.
4. Contesta de forma clara y humana.
Ejemplo:
> “Sí, hay stock disponible y el precio actualizado es $24.500.”
***
### 6️⃣ Qué tiene que saber alguien no-code (y qué pedir)
#### Vos necesitás tener claro:
* Qué querés automatizar.
* En qué sistema está la info.
* Qué datos vas a pedirle al usuario.
* Qué respuesta esperás mostrarle.
#### Alguien técnico tiene que ayudarte con:
* URL exacta del endpoint.
* Método correcto.
* Headers de autenticación.
* Body en el formato correcto.
* Interpretación de la respuesta.
👉 Prometheo **no adivina APIs**: ejecuta exactamente lo que configures.
***
### 7️⃣ Resumen ultra simple
* Prometheo Connect = **conectar APIs externas**.
* Cada endpoint = un **enchufe**.
* El asistente:
* pide datos,
* ejecuta el enchufe,
* explica el resultado.
* Vos definís el proceso.
* Un técnico arma la parte API.
* Después funciona solo 🚀
***
## 🏨 EJEMPLO 1: Reservas de hotel
#### Endpoint 1: consultar disponibilidad
**Nombre:** `consultar_disponibilidad_hotel`\
**Método:** GET o POST\
**Objetivo:** saber qué habitaciones hay disponibles.
Respuesta típica:
```json
{
"rooms": [
{ "id": "STD", "available": true, "price": 80 },
{ "id": "DLX", "available": false, "price": 120 }
]
}
```
Uso en chat:
> “Tengo habitación Standard disponible a 80 USD por noche.”
***
#### Endpoint 2: crear reserva
**Nombre:** `crear_reserva_hotel`\
**Método:** POST
Body incluye:
* habitación
* fechas
* datos del huésped
Respuesta:
```json
{
"booking_id": "BK123",
"status": "confirmed"
}
```
Chat:
> “Listo, tu reserva BK123 está confirmada.”
***
## ✈️ EJEMPLO 2: Compra de pasajes
#### Endpoint 1: buscar vuelos
**Nombre:** `buscar_vuelos`\
**Método:** POST
Respuesta:
```json
{
"flights": [
{ "id": "FL1", "price": 250 },
{ "id": "FL2", "price": 220 }
]
}
```
Chat:
> “Tengo un vuelo a las 08:00 por 250 USD y otro a las 20:00 por 220 USD.”
***
#### Endpoint 2: crear reserva de vuelo
**Nombre:** `crear_reserva_vuelo`\
**Método:** POST
Respuesta:
```json
{
"booking_code": "ABC123",
"status": "confirmed"
}
```
Chat:
> “Tu reserva está confirmada. Código ABC123.”
***
## 🔗 Prometheo Connect + Variables
### Cómo hacer que el asistente tome datos del chat y los envíe a una API
Hasta ahora vimos que Prometheo Connect permite crear endpoints para consultar o crear cosas en sistemas externos.
Pero falta la pieza más importante:
👉 **¿Cómo obtiene el asistente los datos que necesita para enviar a la API?**
La respuesta es: **Variables**.
***
## 🧠 Qué rol cumplen las Variables en Prometheo Connect
Las variables son campos que el asistente completa automáticamente leyendo la conversación.
Ejemplo:
* Variable: `dni`
* Descripción: “Guarda en esta variable el número de DNI que comparta la persona en la conversación.”
Cuando el usuario escribe:
> “Mi DNI es 31234567”
La IA lo detecta y lo guarda.
Ahora esa variable puede usarse dentro de un endpoint.
***
## 🔄 Cómo se conectan Variables + Endpoint
Imaginemos que tu endpoint necesita esto:
```json
{
"document_number": "",
"email": "",
"booking_date": ""
}
```
Si creaste variables:
* `dni`
* `email`
* `fecha_turno`
Prometheo puede:
1. Detectar esos datos en el chat.
2. Guardarlos en variables.
3. Usarlos automáticamente para completar el body del endpoint.
4. Enviar esos valores reales al sistema externo.
👉 El asistente no “inventa” datos: usa lo que extrajo de la conversación.
***
## ⚠️ Punto MUY importante sobre las variables
La calidad de la automatización depende directamente de cómo estén redactadas las descripciones de las variables.
Las descripciones deben ser:
* Claras
* Específicas
* Concisas
* Escritas como instrucción a la IA
#### ❌ Mal ejemplo
“DNI del cliente”
Demasiado ambiguo.
#### ✅ Buen ejemplo
“Guarda en esta variable el número de DNI que la persona comparta en la conversación, solo el número sin puntos ni espacios.”
Mientras más clara sea la descripción:
* Mejor extrae la información.
* Menos errores tiene el endpoint.
* Más estable funciona la integración.
***
## 🛠️ Flujo completo real (Variables + Connect)
Ejemplo: reserva de turno médico.
1️⃣ El asistente pregunta:
> “¿Qué día querés el turno?”\
> “¿Me pasás tu DNI y mail?”
2️⃣ El usuario responde:
> “El martes 12, mi DNI es 31234567 y mi mail ”
3️⃣ Prometheo:
* Guarda fecha en variable `fecha_turno`
* Guarda DNI en `dni`
* Guarda mail en `email`
4️⃣ Se ejecuta el endpoint:
```json
{
"date": "2026-03-12",
"document": "31234567",
"email": "juan@gmail.com"
}
```
5️⃣ El sistema responde:\
“Reserva confirmada.”
6️⃣ El asistente responde al usuario:
> “Listo, tu turno está confirmado para el martes 12.”
Todo automático.
***
## 📌 Buenas prácticas para usar Variables con Connect
#### 1️⃣ Crear solo las variables necesarias
No crees 20 variables si el endpoint usa 4.
#### 2️⃣ No mezclar conceptos
Una variable = un tipo de dato.
#### 3️⃣ Evitar descripciones ambiguas
Ser específico siempre.
#### 4️⃣ Probar antes de producción
Simular conversaciones y verificar que:
* La variable se complete.
* El endpoint reciba el dato correcto.
* La API responda bien.
### 🧠 Punto clave final
Prometheo Connect **no es magia**, es **potencia bien configurada**:
* Lo técnico se arma una vez.
* El asistente hace el resto.
* El cliente ve una conversación natural.
* Vos automatizás procesos reales.