272 lines
11 KiB
Python
272 lines
11 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Telegram Bot AI Integration
|
|
Integrate existing AI Orchestrator for natural language processing
|
|
All responses in Traditional Chinese
|
|
"""
|
|
|
|
import asyncio
|
|
import logging
|
|
from typing import Dict, Any, Optional
|
|
from services.ai_orchestrator import AIOrchestrator
|
|
from datetime import datetime
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class TelegramAIIntegration:
|
|
"""Telegram Bot AI Integration for natural language understanding"""
|
|
|
|
def __init__(self):
|
|
self.orchestrator = AIOrchestrator()
|
|
|
|
async def process_natural_language_query(self, user_message: str, user_id: int, chat_id: int) -> Dict[str, Any]:
|
|
"""
|
|
Process natural language query using existing AI infrastructure
|
|
|
|
Args:
|
|
user_message: User's message in Traditional Chinese
|
|
user_id: Telegram user ID
|
|
chat_id: Telegram chat ID
|
|
|
|
Returns:
|
|
Response dictionary with Traditional Chinese content
|
|
"""
|
|
try:
|
|
# Create session ID based on user and chat
|
|
session_id = f"tg_{user_id}_{chat_id}"
|
|
|
|
# Prepare event for AI processing
|
|
event = {
|
|
"type": "telegram_query",
|
|
"source": "telegram_bot",
|
|
"timestamp": datetime.now().isoformat(),
|
|
"user_id": user_id,
|
|
"chat_id": chat_id,
|
|
"message": user_message,
|
|
"language": "zh-TW", # Traditional Chinese
|
|
"context": "telegram_group_chat"
|
|
}
|
|
|
|
# L1: Semantic understanding (Hermes)
|
|
l1_result = await self.orchestrator.handle_l1(event, session_id)
|
|
|
|
# Check if this is a complex query requiring L2 processing
|
|
if self._is_complex_query(user_message, l1_result):
|
|
# L2: Planning and execution (Nemotron)
|
|
l2_result = await self.orchestrator.handle_l2(event, session_id)
|
|
return self._format_complex_response(l1_result, l2_result, user_message)
|
|
else:
|
|
# Simple query, handle directly
|
|
return self._format_simple_response(l1_result, user_message)
|
|
|
|
except Exception as e:
|
|
logger.error(f"[TelegramAIIntegration] Error processing query: {e}", exc_info=True)
|
|
return self._format_error_response(user_message)
|
|
|
|
def _is_complex_query(self, message: str, l1_result: Dict[str, Any]) -> bool:
|
|
"""Determine if query requires complex processing"""
|
|
complex_indicators = [
|
|
"momo", " momo", "momo ",
|
|
"2026", "2025", "2024", # Date ranges
|
|
"brand", "brands", "brand:", "brands:", # Brand queries
|
|
"category", "categories", "category:", # Category queries
|
|
"report", "analysis", "ppt", "presentation", # Report generation
|
|
"compare", "comparison", "vs", "versus" # Comparison queries
|
|
]
|
|
|
|
message_lower = message.lower()
|
|
|
|
# Check for complex indicators
|
|
for indicator in complex_indicators:
|
|
if indicator in message_lower:
|
|
return True
|
|
|
|
# Check L1 analysis result
|
|
if l1_result.get("complexity_score", 0) > 0.7:
|
|
return True
|
|
|
|
if l1_result.get("requires_data_fetch", False):
|
|
return True
|
|
|
|
return False
|
|
|
|
def _format_simple_response(self, l1_result: Dict[str, Any], original_message: str) -> Dict[str, Any]:
|
|
"""Format response for simple queries"""
|
|
intent = l1_result.get("intent", "unknown")
|
|
confidence = l1_result.get("confidence", 0.0)
|
|
|
|
# Traditional Chinese responses based on intent
|
|
responses = {
|
|
"greeting": {
|
|
"text": "Hello! I am the MOMO Pro Assistant. How can I help you today?",
|
|
"zh_tw": "Hello! I am the MOMO Pro Assistant. How can I help you today?",
|
|
"suggestions": ["Check today's sales", "View product rankings", "Market intelligence"]
|
|
},
|
|
"help": {
|
|
"text": "I can help you with sales queries, product information, market intelligence, and more. Please use the menu or ask specific questions.",
|
|
"zh_tw": "I can help you with sales queries, product information, market intelligence, and more. Please use the menu or ask specific questions.",
|
|
"suggestions": ["Sales performance", "Product trends", "Market analysis"]
|
|
},
|
|
"unknown": {
|
|
"text": "I'm processing your request. Please use the menu options for specific functions.",
|
|
"zh_tw": "I'm processing your request. Please use the menu options for specific functions.",
|
|
"suggestions": ["View main menu", "Check sales data", "Product analysis"]
|
|
}
|
|
}
|
|
|
|
response_data = responses.get(intent, responses["unknown"])
|
|
|
|
return {
|
|
"success": True,
|
|
"type": "simple_response",
|
|
"intent": intent,
|
|
"confidence": confidence,
|
|
"response_text": response_data["zh_tw"],
|
|
"suggestions": response_data["suggestions"],
|
|
"show_menu": intent == "unknown"
|
|
}
|
|
|
|
def _format_complex_response(self, l1_result: Dict[str, Any], l2_result: Dict[str, Any], original_message: str) -> Dict[str, Any]:
|
|
"""Format response for complex queries requiring data fetching"""
|
|
action_plan = l2_result.get("action_plan", {})
|
|
|
|
# Extract relevant information
|
|
query_type = self._extract_query_type(original_message)
|
|
date_range = self._extract_date_range(original_message)
|
|
brands = self._extract_brands(original_message)
|
|
|
|
# Traditional Chinese response
|
|
response_text = f"Processing your {query_type} request"
|
|
|
|
if date_range:
|
|
response_text += f" for period {date_range}"
|
|
if brands:
|
|
response_text += f" for brands: {', '.join(brands)}"
|
|
|
|
response_text += ". I'm preparing the analysis..."
|
|
|
|
return {
|
|
"success": True,
|
|
"type": "complex_response",
|
|
"query_type": query_type,
|
|
"date_range": date_range,
|
|
"brands": brands,
|
|
"action_plan": action_plan,
|
|
"response_text": response_text,
|
|
"requires_processing": True,
|
|
"processing_status": "queued"
|
|
}
|
|
|
|
def _format_error_response(self, original_message: str) -> Dict[str, Any]:
|
|
"""Format error response in Traditional Chinese"""
|
|
return {
|
|
"success": False,
|
|
"type": "error_response",
|
|
"response_text": "Sorry, I encountered an error processing your request. Please try using the menu options.",
|
|
"error_suggestions": [
|
|
"Check today's sales performance",
|
|
"View product rankings",
|
|
"Market intelligence summary",
|
|
"Use /help for available commands"
|
|
],
|
|
"show_menu": True
|
|
}
|
|
|
|
def _extract_query_type(self, message: str) -> str:
|
|
"""Extract type of query from message"""
|
|
if any(word in message.lower() for word in ["sales", "revenue", "performance"]):
|
|
return "sales analysis"
|
|
elif any(word in message.lower() for word in ["product", "brand", "item"]):
|
|
return "product analysis"
|
|
elif any(word in message.lower() for word in ["market", "trend", "intelligence"]):
|
|
return "market intelligence"
|
|
elif any(word in message.lower() for word in ["report", "ppt", "presentation"]):
|
|
return "report generation"
|
|
elif any(word in message.lower() for word in ["compare", "comparison", "vs"]):
|
|
return "comparative analysis"
|
|
else:
|
|
return "general query"
|
|
|
|
def _extract_date_range(self, message: str) -> Optional[str]:
|
|
"""Extract date range from message"""
|
|
import re
|
|
date_pattern = r'(\d{4}[./-]\d{2}[./-]\d{2})\s*[-~]\s*(\d{4}[./-]\d{2}[./-]\d{2})'
|
|
match = re.search(date_pattern, message)
|
|
|
|
if match:
|
|
start = match.group(1).replace('/', '-').replace('.', '-')
|
|
end = match.group(2).replace('/', '-').replace('.', '-')
|
|
return f"{start} to {end}"
|
|
|
|
return None
|
|
|
|
def _extract_brands(self, message: str) -> list:
|
|
"""Extract brand names from message (Chinese and English)"""
|
|
# Brand mapping: Chinese name -> English name
|
|
brand_mapping = {
|
|
# Chinese -> English mapping
|
|
"nivea": "Nivea",
|
|
"loreal": "Loreal",
|
|
"sk-ii": "SK-II",
|
|
"kiehls": "Kiehls",
|
|
"clinique": "Clinique",
|
|
"dior": "Dior",
|
|
"chanel": "Chanel",
|
|
"ysl": "YSL",
|
|
"givenchy": "Givenchy",
|
|
"hermes": "Hermes",
|
|
"gucci": "Gucci",
|
|
"prada": "Prada",
|
|
"versace": "Versace",
|
|
"armani": "Armani",
|
|
"coach": "Coach",
|
|
"michael kors": "Michael Kors",
|
|
# Specific Chinese brand names from user query
|
|
"neutrogena": "Neutrogena", # English name used in Chinese
|
|
"aveeno": "Aveeno", # English name used in Chinese
|
|
"estee lauder": "Estee Lauder",
|
|
"lancome": "Lancome",
|
|
"biotherm": "Biotherm",
|
|
"clarins": "Clarins",
|
|
"nars": "NARS",
|
|
"bobbi brown": "Bobbi Brown",
|
|
"mac": "MAC",
|
|
"tumi": "Tumi",
|
|
"samsonite": "Samsonite",
|
|
"longchamp": "Longchamp",
|
|
"shiseido": "Shiseido"
|
|
}
|
|
|
|
# Also include direct Chinese variations
|
|
chinese_variations = {
|
|
"nivea": "Nivea",
|
|
"loreal": "Loreal",
|
|
"sk-ii": "SK-II",
|
|
"kiehls": "Kiehls",
|
|
"clinique": "Clinique",
|
|
"dior": "Dior",
|
|
"chanel": "Chanel",
|
|
"neutrogena": "Neutrogena",
|
|
"aveeno": "Aveeno"
|
|
}
|
|
|
|
# Combine all brand mappings
|
|
all_brands = {**brand_mapping, **chinese_variations}
|
|
|
|
message_lower = message.lower()
|
|
found_brands = []
|
|
|
|
for brand_key, brand_name in all_brands.items():
|
|
if brand_key in message_lower:
|
|
if brand_name not in found_brands:
|
|
found_brands.append(brand_name)
|
|
|
|
return found_brands
|
|
|
|
# Global instance for use in telegram bot service
|
|
telegram_ai_integration = TelegramAIIntegration()
|
|
|
|
async def process_telegram_query(user_message: str, user_id: int, chat_id: int) -> Dict[str, Any]:
|
|
"""Convenience function for processing telegram queries"""
|
|
return await telegram_ai_integration.process_natural_language_query(user_message, user_id, chat_id)
|