Mensajería con IA: Telegram, Slack, WhatsApp y Teams en piloto automático

import os
import logging
from telegram import Update
from telegram.ext import (
    Application, CommandHandler, MessageHandler,
    filters, ContextTypes
)
import anthropic
from dotenv import load_dotenv

load_dotenv()

claude = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
BOT_TOKEN = os.environ["TELEGRAM_BOT_TOKEN"]

# Historial de la conversación en memoria
# En producción, cámbialo por Redis o SQLite
conversation_history: dict[int, list] = {}

SYSTEM_PROMPT = """Eres el asistente de IA de la inmobiliaria Acme Realty.
Respondes preguntas sobre bienes raíces en Ecuador: precios, zonas, proceso de compra.
Tono: experto amable, no vendedor.
Si la pregunta requiere la asesoría de un asesor, dilo con claridad y ofrece dejar un contacto.
Responde breve: 1–3 oraciones si la pregunta es simple, hasta 5 párrafos si es compleja.
Idioma: español."""


async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Comando /start: saludo al usuario nuevo."""
    user = update.effective_user
    await update.message.reply_text(
        f"¡Hola, {user.first_name}! 👋\n\n"
        "Te ayudo con tus preguntas sobre bienes raíces en Cuenca, Ecuador. "
        "Pregunta por precios, zonas o el proceso de compra y te respondo al instante.\n\n"
        "Si necesitas una asesoría personal, solo dímelo."
    )


async def cmd_contact(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Comando /contact: pide los datos de contacto."""
    await update.message.reply_text(
        "Déjanos tu email o tu teléfono, "
        "y un asesor te contactará en menos de 2 horas en horario laboral."
    )
    # En un bot real aquí va un ConversationHandler para recibir y guardar el contacto


async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """El manejador principal de los mensajes entrantes."""
    user_id = update.effective_user.id
    user_text = update.message.text

    # Inicializamos el historial si es el primer mensaje
    if user_id not in conversation_history:
        conversation_history[user_id] = []

    # Agregamos el mensaje del usuario
    conversation_history[user_id].append({
        "role": "user",
        "content": user_text
    })

    # Limitamos el historial: los últimos 10 mensajes
    if len(conversation_history[user_id]) > 10:
        conversation_history[user_id] = conversation_history[user_id][-10:]

    # Mostramos "escribiendo..." para una buena experiencia
    await context.bot.send_chat_action(
        chat_id=update.effective_chat.id,
        action="typing"
    )

    # Solicitud a Claude (modelos vigentes: página «Lo vigente»)
    response = claude.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=1024,
        system=SYSTEM_PROMPT,
        messages=conversation_history[user_id]
    )

    assistant_reply = "".join(b.text for b in response.content if b.type == "text")

    # Guardamos la respuesta en el historial
    conversation_history[user_id].append({
        "role": "assistant",
        "content": assistant_reply
    })

    await update.message.reply_text(assistant_reply)


async def handle_error(update: object, context: ContextTypes.DEFAULT_TYPE):
    """Registramos los errores."""
    logging.error("Exception while handling update:", exc_info=context.error)


def main():
    app = Application.builder().token(BOT_TOKEN).build()

    app.add_handler(CommandHandler("start", cmd_start))
    app.add_handler(CommandHandler("contact", cmd_contact))
    app.add_handler(MessageHandler(
        filters.TEXT & ~filters.COMMAND, handle_message
    ))
    app.add_error_handler(handle_error)

    print("Bot de Telegram en marcha (modo polling)...")
    app.run_polling(allowed_updates=Update.ALL_TYPES)


if __name__ == "__main__":
    main()

from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
import anthropic
import os

app = App(token=os.environ["SLACK_BOT_TOKEN"])
claude = anthropic.Anthropic()


@app.event("app_mention")
def handle_mention(event, say):
    """Responde cuando alguien menciona al bot con @."""
    user_text = event["text"]

    # Quitamos la @mención del bot del texto
    clean_text = user_text.split(">", 1)[-1].strip() if ">" in user_text else user_text

    response = claude.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=512,
        system="Eres el asistente del equipo de desarrollo. Responde breve y concreto.",
        messages=[{"role": "user", "content": clean_text}]
    )

    say(f"<@{event['user']}> {''.join(b.text for b in response.content if b.type == 'text')}")


@app.command("/standup")
def handle_standup(ack, say, command):
    """
    /standup: genera el formulario del standup.
    El usuario lo llena, el bot junta las respuestas y hace un resumen.
    """
    ack()
    say({
        "blocks": [
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"*Standup de {command['user_name']}*\n"
                            "Responde tres preguntas:"
                }
            },
            {
                "type": "input",
                "block_id": "done",
                "element": {
                    "type": "plain_text_input",
                    "action_id": "done_input",
                    "placeholder": {"type": "plain_text", "text": "¿Qué hiciste ayer?"}
                },
                "label": {"type": "plain_text", "text": "Hecho"}
            }
        ]
    })


@app.command("/summarize")
def handle_summarize(ack, say, command):
    """
    /summarize [texto]: resume un mensaje largo.
    Útil para descripciones largas de PR o documentos en los canales.
    """
    ack()
    text_to_summarize = command.get("text", "")

    if not text_to_summarize:
        say("Escribe el texto después del comando: `/summarize [tu texto]`")
        return

    response = claude.messages.create(
        model="claude-haiku-4-5",
        max_tokens=300,
        messages=[{
            "role": "user",
            "content": f"Resume este texto en 3–5 puntos:\n\n{text_to_summarize}"
        }]
    )

    say(f"📋 *Resumen:*\n{''.join(b.text for b in response.content if b.type == 'text')}")


if __name__ == "__main__":
    handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"])
    print("Bot de Slack en marcha...")
    handler.start()

from flask import Flask, request
from twilio.twiml.messaging_response import MessagingResponse
from twilio.rest import Client
import anthropic
import os

app = Flask(__name__)
twilio_client = Client(
    os.environ["TWILIO_ACCOUNT_SID"],
    os.environ["TWILIO_AUTH_TOKEN"]
)
claude = anthropic.Anthropic()

# Historial de conversaciones (en producción: Redis con TTL de 24 h)
wa_conversations: dict[str, list] = {}

WA_SYSTEM = """Eres el asistente de IA de la empresa en WhatsApp.
Responde breve (WhatsApp no es email).
Si la pregunta requiere a un asesor, di: 'Te paso con un especialista, te responde en menos de una hora.'
Sé amable, pero profesional."""


@app.route("/webhook/whatsapp", methods=["POST"])
def whatsapp_webhook():
    """Procesa los mensajes entrantes de WhatsApp."""
    from_number = request.form.get("From", "")
    body = request.form.get("Body", "").strip()

    if not body:
        return str(MessagingResponse())

    # Historial de la conversación
    if from_number not in wa_conversations:
        wa_conversations[from_number] = []

    wa_conversations[from_number].append(
        {"role": "user", "content": body}
    )

    # Limitamos el contexto a los últimos 8 mensajes
    history = wa_conversations[from_number][-8:]

    # Claude genera la respuesta
    response = claude.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=512,
        system=WA_SYSTEM,
        messages=history
    )

    reply = "".join(b.text for b in response.content if b.type == "text")

    wa_conversations[from_number].append(
        {"role": "assistant", "content": reply}
    )

    # Si Claude pasa el caso a un asesor, avisamos internamente
    if "especialista" in reply.lower() or "te paso" in reply.lower():
        notify_manager(from_number, body, reply)

    # Respondemos al usuario
    resp = MessagingResponse()
    resp.message(reply)
    return str(resp)


def notify_manager(customer_number: str, question: str, bot_reply: str):
    """Avisamos al responsable por Telegram cuando el bot no puede ayudar."""
    import requests
    telegram_token = os.environ.get("TELEGRAM_BOT_TOKEN")
    manager_chat = os.environ.get("MANAGER_TELEGRAM_CHAT_ID")

    if not telegram_token or not manager_chat:
        return

    message = (
        f"🔔 *Escalamiento desde WhatsApp*\n\n"
        f"Cliente: `{customer_number}`\n"
        f"Pregunta: {question}\n\n"
        f"El bot respondió: {bot_reply[:200]}..."
    )
    requests.post(
        f"https://api.telegram.org/bot{telegram_token}/sendMessage",
        json={
            "chat_id": manager_chat,
            "text": message,
            "parse_mode": "Markdown"
        }
    )


if __name__ == "__main__":
    app.run(port=5001, debug=False)

import requests
import json
import os

TEAMS_WEBHOOK_URL = os.environ["TEAMS_WEBHOOK_URL"]


def send_teams_notification(title: str, message: str,
                             color: str = "0078D4",
                             facts: list[dict] = None) -> bool:
    """
    Envía una tarjeta de notificación a un canal de Teams con la dirección webhook de Workflows.
    Workflows acepta MessageCard y Adaptive Card: revisa el formato en un canal de prueba.
    color: color hex de la franja lateral (0078D4 = azul de Microsoft)
    facts: lista de {"name": "...", "value": "..."} para la tabla de datos
    """
    card = {
        "@type": "MessageCard",
        "@context": "http://schema.org/extensions",
        "themeColor": color,
        "summary": title,
        "sections": [{
            "activityTitle": title,
            "activityText": message,
        }]
    }

    if facts:
        card["sections"][0]["facts"] = facts

    response = requests.post(
        TEAMS_WEBHOOK_URL,
        headers={"Content-Type": "application/json"},
        data=json.dumps(card)
    )
    return response.ok   # cualquier respuesta exitosa (200, 202)


# Ejemplo: aviso de una venta nueva
def notify_deal_closed(client_name: str, amount: float,
                        property_address: str) -> None:
    """Aviso en el canal de ventas de Teams cuando se cierra un negocio."""
    send_teams_notification(
        title="🎉 ¡Se cerró un negocio nuevo!",
        message=f"El asesor firmó el contrato con el cliente.",
        color="00B050",   # verde
        facts=[
            {"name": "Cliente", "value": client_name},
            {"name": "Monto", "value": f"${amount:,.0f}"},
            {"name": "Propiedad", "value": property_address},
        ]
    )

from flask import Flask, request, jsonify
import anthropic
import json
import os

app = Flask(__name__)
claude = anthropic.Anthropic()

ROUTING_SYSTEM = """Eres un enrutador de mensajes de clientes. Analiza la solicitud y devuelve JSON:
{
  "intent": "faq|lead|complaint|consultation|other",
  "urgency": "low|medium|high",
  "language": "es|en|pt",
  "should_escalate": true|false,
  "suggested_response": "respuesta breve si intent=faq"
}"""


def route_message(message: str, channel: str, user_id: str) -> dict:
    """
    Analiza el mensaje entrante y decide la ruta.
    channel: telegram|whatsapp|slack|teams
    """
    response = claude.messages.create(
        model="claude-haiku-4-5",   # Haiku para enrutar: rápido y barato; comprueba que el modelo siga disponible
        max_tokens=256,
        system=ROUTING_SYSTEM,
        messages=[{
            "role": "user",
            "content": f"Canal: {channel}\nMensaje: {message}"
        }]
    )

    try:
        return json.loads("".join(b.text for b in response.content if b.type == "text"))
    except json.JSONDecodeError:
        return {
            "intent": "other",
            "urgency": "medium",
            "language": "es",
            "should_escalate": False,
            "suggested_response": ""
        }


@app.route("/hub/incoming", methods=["POST"])
def unified_incoming():
    """
    Una sola entrada para los mensajes de todos los canales.
    Cada fuente (bot de Telegram, webhook de WhatsApp, evento de Slack)
    manda el mensaje aquí en un formato estandarizado.
    """
    data = request.json
    channel = data.get("channel", "unknown")
    user_id = data.get("user_id", "")
    message = data.get("message", "")

    # 1. Enrutamiento con Claude Haiku (barato y rápido)
    routing = route_message(message, channel, user_id)

    # 2. Lógica según la intención
    if routing["should_escalate"]:
        # Lo pasamos a una persona
        escalate_to_manager(channel, user_id, message, routing)
        reply = "Paso tu pregunta a un especialista. Te respondemos en menos de 1 hora."

    elif routing["intent"] == "faq" and routing["suggested_response"]:
        # Usamos la respuesta lista del enrutamiento
        reply = routing["suggested_response"]

    else:
        # Respuesta completa con Claude Sonnet
        response = claude.messages.create(
            model="claude-sonnet-5-5",
            max_tokens=512,
            system="Eres un asistente amable. Responde en el idioma del cliente.",
            messages=[{"role": "user", "content": message}]
        )
        reply = "".join(b.text for b in response.content if b.type == "text")

    return jsonify({
        "reply": reply,
        "routing": routing,
        "channel": channel
    })


def escalate_to_manager(channel: str, user_id: str,
                         message: str, routing: dict) -> None:
    """Avisa al responsable por Telegram."""
    bot_token = os.environ.get("TELEGRAM_BOT_TOKEN")
    manager_chat = os.environ.get("MANAGER_TELEGRAM_CHAT_ID")
    if not bot_token or not manager_chat:
        return

    import requests
    requests.post(
        f"https://api.telegram.org/bot{bot_token}/sendMessage",
        json={
            "chat_id": manager_chat,
            "text": (
                f"🔔 *Escalamiento*\n"
                f"Canal: {channel} | Usuario: `{user_id}`\n"
                f"Urgencia: {routing.get('urgency', '?')}\n"
                f"Mensaje: {message[:300]}"
            ),
            "parse_mode": "Markdown"
        }
    )


if __name__ == "__main__":
    app.run(port=5002, debug=False)

mkdir ai-messenger-bot && cd ai-messenger-bot
python -m venv venv && source venv/bin/activate
pip install python-telegram-bot anthropic python-dotenv flask requests

TELEGRAM_BOT_TOKEN=tu_token
ANTHROPIC_API_KEY=sk-ant-...
TEAMS_WEBHOOK_URL=https://...  # lo agregamos en el paso 3
MANAGER_TELEGRAM_CHAT_ID=tu_chat_id

python bot.py

from dotenv import load_dotenv
load_dotenv()
notify_deal_closed("Juan Pérez", 85000, "Calle Larga 45, Cuenca")