Cómo Construir Sistemas de Confirmación Robustos con Telegram Bots

Cómo Construir Sistemas de Confirmación Robustos con Telegram Bots

Cómo Construir Sistemas de Confirmación Robustos con Telegram Bots

Introducción

Cuando desarrollas sistemas automatizados que manejan operaciones críticas, la confiabilidad no es opcional. Un error de interpretación en un comando puede significar la diferencia entre registrar una transacción correctamente o crear inconsistencias en tus datos. En este artículo, exploraremos cómo construir sistemas de confirmación robustos usando Telegram Bot API, basándonos en la implementación real de un sistema de gestión de préstamos que alcanzó 100% de confiabilidad operativa.

El Problema: Interpretación Ambigua de Comandos

Los sistemas tradicionales que dependen de procesamiento de lenguaje natural (NLU) para comandos críticos enfrentan un dilema fundamental: la ambigüedad del lenguaje humano. Cuando un usuario envía "Pago de Fany $800", ¿se refiere a un pago recibido, una promesa de pago, o una consulta? La interpretación incorrecta genera errores costosos.

La Solución: Arquitectura ASK-CONFIRM-ACT

La clave está en separar tres capas:

  1. ASK (Extracción): Usa regex para extraer datos estructurados sin ambigüedad
  2. CONFIRM (Confirmación): Presenta los datos extraídos para validación humana
  3. ACT (Ejecución): Solo ejecuta acciones tras confirmación explícita

Esta arquitectura elimina la interpretación ambigua y coloca al humano como validador final.

Implementación: Sistema de Confirmación con Botones

Paso 1: Extracción Directa con Regex

En lugar de depender de modelos de IA para interpretar, usa patrones regex precisos:

import re
def extract_payment_data(message_text):
# Patrón: Nombre $Monto #NumPrestamo
pattern = r'([A-ZÁÉÍÓÚÑ][A-Za-záéíóúñ]+)\s\$([0-9,]+)\s#(\d+)'
matches = re.findall(pattern, message_text)
payments = []
for name, amount, loan_id in matches:
payments.append({
'name': name.upper(),
'amount': float(amount.replace(',', '')),
'loan_id': loan_id
})
return payments

Esta función puede procesar múltiples pagos en un solo mensaje:

Input: "Fany $800 #11, Fabiola $1050 #5"
Output: [
{'name': 'FANY', 'amount': 800.0, 'loan_id': '11'},
{'name': 'FABIOLA', 'amount': 1050.0, 'loan_id': '5'}
]

Paso 2: Botones Inline para Confirmación

Usa la API de Telegram para crear botones de confirmación:

import requests
def send_confirmation_buttons(chat_id, payments, bot_token):
text = "📋 Confirma los siguientes pagos:\n\n"
for p in payments:
text += f"• {p['name']}: ${p['amount']:.2f} (Préstamo #{p['loan_id']})\n"
keyboard = {
"inline_keyboard": [[
{"text": "✅ Confirmar", "callback_data": f"confirm_{generate_id()}"},
{"text": "❌ Cancelar", "callback_data": "cancel"}
]]
}
requests.post(
f"https://api.telegram.org/bot{bot_token}/sendMessage",
json={
"chat_id": chat_id,
"text": text,
"reply_markup": keyboard
}
)

Paso 3: Protección contra Duplicados

Implementa idempotency keys para prevenir ejecuciones duplicadas:

import hashlib
import json
processed_confirmations = set()
def generate_idempotency_key(payment_data):
data_string = json.dumps(payment_data, sort_keys=True)
return hashlib.sha256(data_string.encode()).hexdigest()[:16]
def process_confirmation(callback_data, payment_data):
idempotency_key = generate_idempotency_key(payment_data)
if idempotency_key in processed_confirmations:
return {"status": "duplicate", "message": "Ya procesado"}
# Ejecutar operación crítica
result = register_payments(payment_data)
if result['success']:
processed_confirmations.add(idempotency_key)
return result

Monitoreo en Tiempo Real con inotify

Para sistemas que requieren alertas inmediatas, implementa monitoring basado en eventos del sistema de archivos:

#!/bin/bash
DB_FILE="/path/to/database.csv"
BOT_TOKEN="your_bot_token"
CHAT_ID="your_chat_id"
inotifywait -m -e modify "$DB_FILE" | while read path action file; do
LAST_LINE=$(tail -n 1 "$DB_FILE")
curl -s -X POST "https://api.telegram.org/bot${BOT_TOKEN}/sendMessage" \
-d "chat_id=${CHAT_ID}" \
-d "text=🔔 Nuevo registro: ${LAST_LINE}"
done

Integra con systemd para ejecución permanente:

[Unit]
Description=Monitor de Base de Datos
After=network.target
[Service]
Type=simple
ExecStart=/path/to/monitor_script.sh
Restart=always
User=appuser
[Install]
WantedBy=multi-user.target

Consideraciones de Permisos y Seguridad

Cuando múltiples servicios interactúan con archivos compartidos, los permisos son críticos:

Asegurar que ambos servicios puedan leer/escribir

chmod 666 /path/to/shared/database.csv

O mejor: usar grupo común

sudo groupadd appgroup
sudo usermod -a -G appgroup service1_user
sudo usermod -a -G appgroup service2_user
chown :appgroup /path/to/shared/database.csv
chmod 660 /path/to/shared/database.csv

Lecciones Aprendidas

1. Simplicidad sobre Inteligencia Artificial

Para operaciones críticas, regex bien diseñadas superan a modelos de IA en confiabilidad. Un patrón `([A-Z]+)\s\$([0-9,]+)\s#(\d+)` nunca interpretará mal si los usuarios siguen el formato.

2. Confirmación Explícita Obligatoria

Nunca ejecutes operaciones críticas sin confirmación humana explícita. Los botones inline de Telegram eliminan ambigüedad: el usuario debe hacer clic en ✅ o ❌.

3. Idempotencia por Defecto

Toda operación debe ser idempotente. Genera keys únicas basadas en el contenido de la operación, no en timestamps o IDs secuenciales.

4. Evita Opciones Numeradas

No preguntes "Elige: 1) Confirmar 2) Cancelar". Los usuarios pueden responder con contexto adicional que confunde al parser. Usa botones inline que generan callbacks inequívocos.

Conclusión

Construir sistemas confiables para operaciones críticas requiere arquitectura intencional. La combinación de extracción determinística con regex, confirmación explícita mediante botones interactivos, y protección contra duplicados mediante idempotency keys, crea sistemas que alcanzan niveles de confiabilidad superiores al 99%.

La clave está en reconocer cuándo no usar IA: para comandos críticos, la precisión determinística de regex supera la flexibilidad pero ambigüedad del procesamiento de lenguaje natural. Reserva la IA para análisis, recomendaciones y tareas donde la ambigüedad es aceptable, pero mantén las operaciones críticas bajo control determinístico.

Implementa estas técnicas en tu próximo proyecto que maneje transacciones financieras, inventarios o cualquier operación donde un error tenga consecuencias reales. Tu futuro yo te lo agradecerá.

Regresar al blog

Deja un comentario