AI-мессенджеры — Telegram, Slack, WhatsApp и Teams на автопилоте

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"]

# Хранение истории разговора в памяти
# В продакшне замени на Redis или SQLite
conversation_history: dict[int, list] = {}

SYSTEM_PROMPT = """Ты AI-ассистент агентства недвижимости Acme Realty.
Отвечаешь на вопросы о недвижимости в Эквадоре: цены, районы, процесс покупки.
Тон: дружелюбный эксперт, не продажник.
Если вопрос требует консультации менеджера — скажи об этом явно и предложи оставить контакт.
Отвечай кратко: 1–3 предложения если вопрос простой, до 5 абзацев если сложный.
Язык: русский."""


async def cmd_start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Команда /start — приветствие нового пользователя."""
    user = update.effective_user
    await update.message.reply_text(
        f"Привет, {user.first_name}! 👋\n\n"
        "Я помогу с вопросами о недвижимости в Куэнке, Эквадор. "
        "Спросите о ценах, районах, процессе покупки — отвечу мгновенно.\n\n"
        "Если нужна личная консультация — просто скажите."
    )


async def cmd_contact(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Команда /contact — сбор контактных данных."""
    await update.message.reply_text(
        "Оставьте ваш email или телефон для обратной связи, "
        "и менеджер свяжется с вами в течение 2 часов в рабочее время."
    )
    # В реальном боте здесь ConversationHandler для получения и сохранения контакта


async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Основной обработчик входящих сообщений."""
    user_id = update.effective_user.id
    user_text = update.message.text

    # Инициализируем историю если первое сообщение
    if user_id not in conversation_history:
        conversation_history[user_id] = []

    # Добавляем сообщение пользователя
    conversation_history[user_id].append({
        "role": "user",
        "content": user_text
    })

    # Ограничиваем историю: последние 10 сообщений
    if len(conversation_history[user_id]) > 10:
        conversation_history[user_id] = conversation_history[user_id][-10:]

    # Показываем "печатает..." для хорошего UX
    await context.bot.send_chat_action(
        chat_id=update.effective_chat.id,
        action="typing"
    )

    # Запрос к Claude (актуальные модели: страница «Актуальное сейчас»)
    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")

    # Сохраняем ответ в историю
    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):
    """Логируем ошибки."""
    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("Telegram bot запущен (polling mode)...")
    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):
    """Отвечает когда к боту обращаются через @mention."""
    user_text = event["text"]

    # Убираем @упоминание бота из текста
    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="Ты ассистент команды разработки. Отвечай кратко и конкретно.",
        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 — генерирует форму стендапа.
    Пользователь заполняет, бот собирает ответы и делает резюме.
    """
    ack()
    say({
        "blocks": [
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"*Стендап {command['user_name']}*\n"
                            "Ответь на три вопроса:"
                }
            },
            {
                "type": "input",
                "block_id": "done",
                "element": {
                    "type": "plain_text_input",
                    "action_id": "done_input",
                    "placeholder": {"type": "plain_text", "text": "Что сделал вчера?"}
                },
                "label": {"type": "plain_text", "text": "Сделано"}
            }
        ]
    })


@app.command("/summarize")
def handle_summarize(ack, say, command):
    """
    /summarize [текст] — суммаризирует длинное сообщение.
    Полезно для больших PR-описаний или документов в каналах.
    """
    ack()
    text_to_summarize = command.get("text", "")

    if not text_to_summarize:
        say("Укажи текст после команды: `/summarize [твой текст]`")
        return

    response = claude.messages.create(
        model="claude-haiku-4-5",
        max_tokens=300,
        messages=[{
            "role": "user",
            "content": f"Суммаризируй этот текст в 3–5 пунктах:\n\n{text_to_summarize}"
        }]
    )

    say(f"📋 *Краткое содержание:*\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("Slack bot запущен...")
    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()

# История разговоров (в продакшне: Redis с TTL 24h)
wa_conversations: dict[str, list] = {}

WA_SYSTEM = """Ты AI-ассистент компании в WhatsApp.
Отвечай кратко (WhatsApp — не email).
Если вопрос требует менеджера — скажи: 'Передаю вас специалисту, ожидайте ответа в течение часа.'
Будь дружелюбным, но профессиональным."""


@app.route("/webhook/whatsapp", methods=["POST"])
def whatsapp_webhook():
    """Обрабатывает входящие сообщения WhatsApp."""
    from_number = request.form.get("From", "")
    body = request.form.get("Body", "").strip()

    if not body:
        return str(MessagingResponse())

    # История разговора
    if from_number not in wa_conversations:
        wa_conversations[from_number] = []

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

    # Ограничиваем контекст последними 8 сообщениями
    history = wa_conversations[from_number][-8:]

    # Claude генерирует ответ
    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}
    )

    # Если Claude передаёт менеджеру — уведомляем внутри компании
    if "специалисту" in reply.lower() or "передаю" in reply.lower():
        notify_manager(from_number, body, reply)

    # Отвечаем пользователю
    resp = MessagingResponse()
    resp.message(reply)
    return str(resp)


def notify_manager(customer_number: str, question: str, bot_reply: str):
    """Уведомляем менеджера в Telegram когда бот не может помочь."""
    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"🔔 *Эскалация из WhatsApp*\n\n"
        f"Клиент: `{customer_number}`\n"
        f"Вопрос: {question}\n\n"
        f"Бот ответил: {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:
    """
    Отправляет карточку-уведомление в Teams канал через webhook-адрес из Workflows.
    Workflows принимает и MessageCard, и Adaptive Card: формат проверь в тестовом канале.
    color: hex-цвет боковой полосы (0078D4 = синий Microsoft)
    facts: список {"name": "...", "value": "..."} для таблицы данных
    """
    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   # любой успешный ответ (200, 202)


# Пример: уведомление о новой сделке
def notify_deal_closed(client_name: str, amount: float,
                        property_address: str) -> None:
    """Уведомление в Teams канал продаж при закрытии сделки."""
    send_teams_notification(
        title="🎉 Новая сделка закрыта!",
        message=f"Агент подписал договор с клиентом.",
        color="00B050",   # зелёный
        facts=[
            {"name": "Клиент", "value": client_name},
            {"name": "Сумма", "value": f"${amount:,.0f}"},
            {"name": "Объект", "value": property_address},
        ]
    )

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

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

ROUTING_SYSTEM = """Ты роутер клиентских сообщений. Анализируй запрос и верни JSON:
{
  "intent": "faq|lead|complaint|consultation|other",
  "urgency": "low|medium|high",
  "language": "ru|es|en",
  "should_escalate": true|false,
  "suggested_response": "краткий ответ если intent=faq"
}"""


def route_message(message: str, channel: str, user_id: str) -> dict:
    """
    Анализирует входящее сообщение и определяет маршрут.
    channel: telegram|whatsapp|slack|teams
    """
    response = claude.messages.create(
        model="claude-haiku-4-5",   # Haiku для роутинга — быстро и дёшево; проверьте, что модель ещё доступна
        max_tokens=256,
        system=ROUTING_SYSTEM,
        messages=[{
            "role": "user",
            "content": f"Канал: {channel}\nСообщение: {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": "ru",
            "should_escalate": False,
            "suggested_response": ""
        }


@app.route("/hub/incoming", methods=["POST"])
def unified_incoming():
    """
    Единая точка входа для сообщений из всех каналов.
    Каждый источник (Telegram bot, WhatsApp webhook, Slack event)
    отправляет сообщение сюда в стандартизированном формате.
    """
    data = request.json
    channel = data.get("channel", "unknown")
    user_id = data.get("user_id", "")
    message = data.get("message", "")

    # 1. Роутинг через Claude Haiku (дёшево и быстро)
    routing = route_message(message, channel, user_id)

    # 2. Логика обработки по интенту
    if routing["should_escalate"]:
        # Передаём живому менеджеру
        escalate_to_manager(channel, user_id, message, routing)
        reply = "Я передаю ваш вопрос специалисту. Ответим в течение 1 часа."

    elif routing["intent"] == "faq" and routing["suggested_response"]:
        # Используем готовый ответ из роутинга
        reply = routing["suggested_response"]

    else:
        # Полный ответ через Claude Sonnet
        response = claude.messages.create(
            model="claude-sonnet-5-5",
            max_tokens=512,
            system="Ты дружелюбный помощник. Отвечай на языке клиента.",
            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:
    """Уведомляет менеджера через 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"🔔 *Эскалация*\n"
                f"Канал: {channel} | Пользователь: `{user_id}`\n"
                f"Срочность: {routing.get('urgency', '?')}\n"
                f"Сообщение: {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=ваш_токен
ANTHROPIC_API_KEY=sk-ant-...
TEAMS_WEBHOOK_URL=https://...  # добавим на шаге 3
MANAGER_TELEGRAM_CHAT_ID=ваш_chat_id

python bot.py

from dotenv import load_dotenv
load_dotenv()
notify_deal_closed("Иван Петров", 85000, "ул. Ларга 45, Куэнка")