Fix telegram bot MCP API parameters compatibility

TUNNEL_SOLUTIONS.md

@@ -0,0 +1,85 @@
+# Решения для стабильного доступа к MCP серверу
+
+## 🔴 Проблема
+LocalTunnel нестабилен - туннели отваливаются, URL меняются при перезапуске.
+
+## ✅ Решения (по порядку предпочтения)
+
+### 1. 🌟 **Ngrok (Рекомендуется)**
+```bash
+# Установка
+npm install -g ngrok
+
+# Бесплатная регистрация: https://ngrok.com/
+# Получить authtoken и добавить:
+ngrok authtoken YOUR_TOKEN
+
+# Запуск (стабильный URL на платном плане)
+ngrok http 8080
+```
+
+**Преимущества:**
+- Более стабильный чем LocalTunnel
+- Платный план дает постоянный URL
+- Лучшая производительность
+
+### 2. 🔧 **Cloudflare Tunnel (Бесплатно + Стабильно)**
+```bash
+# Установка
+npm install -g cloudflared
+
+# Авторизация (один раз)
+cloudflared tunnel login
+
+# Создание туннеля
+cloudflared tunnel create youtube-mcp
+
+# Запуск
+cloudflared tunnel --url http://localhost:8080
+```
+
+**Преимущества:**
+- Бесплатный и стабильный
+- Постоянный URL
+- Отличная производительность
+
+### 3. 💻 **VPS развертывание**
+- Aruba Cloud (от €1/месяц)
+- DigitalOcean (от $5/месяц)
+- Hetzner Cloud (от €3/месяц)
+
+### 4. 🏠 **Локальная сеть + DDNS**
+- No-IP, DuckDNS для динамического DNS
+- Настройка роутера для port forwarding
+
+## 🛠️ Текущее быстрое решение
+
+Когда LocalTunnel отваливается:
+
+1. **Перезапустить туннель:**
+```bash
+npx localtunnel --port 8080
+```
+
+2. **Обновить URL:**
+```bash
+python update_tunnel.py https://new-tunnel-url.loca.lt
+```
+
+3. **Перезапустить бота:**
+```bash
+python run_telegram_bot.py
+```
+
+## 📝 Автоматизация
+
+Можно создать скрипт для автоматического перезапуска при падении туннеля:
+
+```bash
+# restart_tunnel.sh
+while true; do
+    npx localtunnel --port 8080
+    echo "Tunnel disconnected, restarting in 5 seconds..."
+    sleep 5
+done
+``` 

deploy_changes.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""
+Скрипт для быстрого деплоя изменений
+Usage: python deploy_changes.py "commit message"
+"""
+
+import sys
+import subprocess
+import os
+
+def run_command(command, description):
+    """Выполнить команду с описанием"""
+    print(f"🔄 {description}...")
+    try:
+        result = subprocess.run(command, shell=True, check=True, capture_output=True, text=True)
+        print(f"✅ {description} - успешно")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ {description} - ошибка: {e.stderr}")
+        return False
+
+def main():
+    if len(sys.argv) != 2:
+        print("Usage: python deploy_changes.py \"commit message\"")
+        print("Example: python deploy_changes.py \"Fix telegram bot MCP parameters\"")
+        sys.exit(1)
+    
+    commit_message = sys.argv[1]
+    
+    print("🚀 Начинаем деплой изменений...")
+    
+    # 1. Git add
+    if not run_command("git add .", "Добавление файлов в git"):
+        return
+    
+    # 2. Git commit
+    if not run_command(f'git commit -m "{commit_message}"', "Создание коммита"):
+        return
+    
+    # 3. Git push
+    if not run_command("git push", "Отправка в удаленный репозиторий"):
+        return
+    
+    print("\n✅ Изменения успешно отправлены!")
+    print("\n📋 Следующие шаги на удаленном сервере:")
+    print("1. git pull")
+    print("2. Перезапустить MCP сервер: python main.py --mode api --host 0.0.0.0 --port 8080")
+    print("3. Перезапустить Telegram бота: python run_telegram_bot.py")
+    print("\n🔗 Или используйте команду:")
+    print("ssh your-server 'cd /path/to/project && git pull && pkill -f main.py && python main.py --mode api --host 0.0.0.0 --port 8080 &'")
+
+if __name__ == "__main__":
+    main() 

run_telegram_bot.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""
+TubeMeta Telegram Bot Launcher
+Run this script to start the Telegram bot that integrates with the MCP server.
+"""
+
+import asyncio
+import sys
+import logging
+from telegram_bot import main
+
+def setup_logging():
+    """Setup logging configuration"""
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler('telegram_bot.log'),
+            logging.StreamHandler(sys.stdout)
+        ]
+    )
+
+if __name__ == "__main__":
+    print("🤖 Starting TubeMeta Telegram Bot...")
+    print("📋 Make sure your MCP server is running at: https://ag-source-knowledge-internal.trycloudflare.com")
+    print("📱 Bot username: @tubemeta_bot")
+    print("🔗 Bot link: https://t.me/tubemeta_bot")
+    print("⏹️  Press Ctrl+C to stop\n")
+    
+    setup_logging()
+    
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\n🛑 Bot stopped by user")
+    except Exception as e:
+        print(f"❌ Error starting bot: {e}")
+        logging.error(f"Bot startup error: {e}")
+        sys.exit(1) 

telegram_bot.py

@@ -0,0 +1,342 @@
+import asyncio
+import json
+import logging
+from typing import Optional
+import aiohttp
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import Application, CommandHandler, MessageHandler, CallbackQueryHandler, filters, ContextTypes
+from telegram.constants import ParseMode
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configuration
+TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN", "8168377961:AAHG-9KyFczCTkBo92ZS9OYKIY62s-NmuVo")
+MCP_BASE_URL = os.getenv("MCP_BASE_URL", "https://ag-source-knowledge-internal.trycloudflare.com/api/mcp")
+
+# Set up logging
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+
+class TubeMetaBot:
+    def __init__(self):
+        self.app = Application.builder().token(TELEGRAM_TOKEN).build()
+        self.setup_handlers()
+    
+    def setup_handlers(self):
+        """Set up command and message handlers"""
+        self.app.add_handler(CommandHandler("start", self.start_command))
+        self.app.add_handler(CommandHandler("help", self.help_command))
+        self.app.add_handler(CommandHandler("search", self.search_command))
+        self.app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, self.handle_message))
+        self.app.add_handler(CallbackQueryHandler(self.handle_callback))
+    
+    async def start_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle /start command"""
+        welcome_text = """
+🎬 **Welcome to TubeMeta Bot!**
+
+I can help you with YouTube videos:
+• 🔍 Search for videos
+• 📊 Get video metadata  
+• 📝 Extract transcripts
+• ⏰ Generate AI timecodes with Gemini 2.0
+
+**How to use:**
+• Send me a YouTube URL for full analysis
+• Use `/search <query>` to find videos
+• Send any text to search YouTube
+
+Type `/help` for more information!
+        """
+        await update.message.reply_text(welcome_text, parse_mode=ParseMode.MARKDOWN)
+    
+    async def help_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle /help command"""
+        help_text = """
+🤖 **TubeMeta Bot Help**
+
+**Commands:**
+• `/start` - Welcome message
+• `/help` - Show this help
+• `/search <query>` - Search YouTube videos
+
+**Features:**
+• 🔍 **Video Search** - Find YouTube videos by keywords
+• 📊 **Video Info** - Get detailed metadata (title, duration, views, etc.)
+• 📝 **Transcripts** - Extract video transcripts/subtitles
+• ⏰ **AI Timecodes** - Generate smart timecodes with Gemini 2.0
+
+**Usage Examples:**
+• Send YouTube URL: `https://youtu.be/dQw4w9WgXcQ`
+• Search: `/search machine learning tutorial`
+• Or just send: `python programming`
+
+**Supported Languages:**
+🇺🇦 Ukrainian | 🇷🇺 Russian | 🇬🇧 English
+
+Powered by Gemini 2.0 AI 🧠
+        """
+        await update.message.reply_text(help_text, parse_mode=ParseMode.MARKDOWN)
+    
+    async def search_command(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle /search command"""
+        if not context.args:
+            await update.message.reply_text("Please provide a search query. Example: `/search python tutorial`")
+            return
+        
+        query = " ".join(context.args)
+        await self.handle_search(update, query)
+    
+    async def handle_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle regular text messages"""
+        text = update.message.text.strip()
+        
+        # Check if it's a YouTube URL
+        if self.is_youtube_url(text):
+            await self.handle_youtube_url(update, text)
+        else:
+            # Treat as search query
+            await self.handle_search(update, text)
+    
+    def is_youtube_url(self, text: str) -> bool:
+        """Check if text contains a YouTube URL"""
+        youtube_domains = [
+            'youtube.com', 'youtu.be', 'www.youtube.com', 
+            'm.youtube.com', 'music.youtube.com'
+        ]
+        return any(domain in text.lower() for domain in youtube_domains)
+    
+    async def handle_youtube_url(self, update: Update, url: str):
+        """Handle YouTube URL - provide full analysis options"""
+        # Send initial message
+        processing_msg = await update.message.reply_text("🔍 Analyzing YouTube video...")
+        
+        try:
+            # Get basic video info first
+            video_info = await self.call_mcp_action("video_info", {"video_id": url})
+            
+            if not video_info or "error" in video_info:
+                await processing_msg.edit_text("❌ Could not analyze this YouTube video. Please check the URL.")
+                return
+            
+            # Format video info
+            info_text = self.format_video_info(video_info)
+            
+            # Create action buttons
+            keyboard = [
+                [
+                    InlineKeyboardButton("📝 Get Transcript", callback_data=f"transcript:{url}"),
+                    InlineKeyboardButton("⏰ AI Timecodes", callback_data=f"timecodes:{url}")
+                ],
+                [
+                    InlineKeyboardButton("🔍 Search Similar", callback_data=f"search:{video_info.get('title', 'related videos')}")
+                ]
+            ]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+            
+            await processing_msg.edit_text(info_text, reply_markup=reply_markup, parse_mode=ParseMode.MARKDOWN)
+            
+        except Exception as e:
+            logger.error(f"Error handling YouTube URL: {e}")
+            await processing_msg.edit_text("❌ An error occurred while analyzing the video.")
+    
+    async def handle_search(self, update: Update, query: str):
+        """Handle search query"""
+        processing_msg = await update.message.reply_text(f"🔍 Searching for: *{query}*", parse_mode=ParseMode.MARKDOWN)
+        
+        try:
+            results = await self.call_mcp_action("search", {"query": query, "max_results": 5})
+            
+            if not results or "error" in results:
+                await processing_msg.edit_text("❌ No results found for your search.")
+                return
+            
+            # Format search results
+            search_text = f"🔍 **Search Results for:** {query}\n\n"
+            
+            for i, video in enumerate(results.get("videos", []), 1):
+                search_text += f"**{i}. {video.get('title', 'Unknown Title')}**\n"
+                search_text += f"👤 {video.get('channel', 'Unknown Channel')}\n"
+                search_text += f"⏱️ {video.get('duration', 'Unknown')}\n"
+                search_text += f"👁️ {video.get('view_count', 'Unknown')} views\n"
+                search_text += f"🔗 {video.get('url', '')}\n\n"
+            
+            # Add search refinement buttons
+            keyboard = [
+                [InlineKeyboardButton("🔍 New Search", callback_data="new_search")]
+            ]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+            
+            await processing_msg.edit_text(search_text, reply_markup=reply_markup, parse_mode=ParseMode.MARKDOWN)
+            
+        except Exception as e:
+            logger.error(f"Error handling search: {e}")
+            await processing_msg.edit_text("❌ An error occurred during search.")
+    
+    async def handle_callback(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
+        """Handle inline keyboard callbacks"""
+        query = update.callback_query
+        await query.answer()
+        
+        data = query.data
+        
+        if data.startswith("transcript:"):
+            url = data.replace("transcript:", "")
+            await self.get_transcript(query, url)
+        elif data.startswith("timecodes:"):
+            url = data.replace("timecodes:", "")
+            await self.get_timecodes(query, url)
+        elif data.startswith("search:"):
+            search_query = data.replace("search:", "")
+            await self.handle_search_callback(query, search_query)
+        elif data == "new_search":
+            await query.edit_message_text("🔍 Send me a search query or YouTube URL!")
+    
+    async def get_transcript(self, query, url: str):
+        """Get video transcript"""
+        await query.edit_message_text("📝 Extracting transcript...")
+        
+        try:
+            transcript = await self.call_mcp_action("transcript", {"video_id": url})
+            
+            if not transcript or "error" in transcript:
+                await query.edit_message_text("❌ Could not extract transcript. Video may not have subtitles or may be restricted.")
+                return
+            
+            # Format transcript
+            transcript_text = f"📝 **Transcript**\n\n{transcript.get('text', 'No transcript available')}"
+            
+            # Telegram message limit is 4096 characters
+            if len(transcript_text) > 4000:
+                transcript_text = transcript_text[:4000] + "...\n\n*Transcript truncated due to length*"
+            
+            # Add back button
+            keyboard = [[InlineKeyboardButton("⬅️ Back", callback_data=f"back:{url}")]]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+            
+            await query.edit_message_text(transcript_text, reply_markup=reply_markup, parse_mode=ParseMode.MARKDOWN)
+            
+        except Exception as e:
+            logger.error(f"Error getting transcript: {e}")
+            await query.edit_message_text("❌ An error occurred while extracting transcript.")
+    
+    async def get_timecodes(self, query, url: str):
+        """Generate AI timecodes"""
+        await query.edit_message_text("⏰ Generating AI timecodes with Gemini 2.0...")
+        
+        try:
+            timecodes = await self.call_mcp_action("gemini_timecodes", {
+                "video_id": url,
+                "language_code": "en",
+                "format": "youtube"
+            })
+            
+            if not timecodes or "error" in timecodes:
+                await query.edit_message_text("❌ Could not generate timecodes. Video may not have transcript or may be restricted.")
+                return
+            
+            # Format timecodes
+            timecodes_text = f"⏰ **AI Generated Timecodes**\n\n{timecodes.get('timecodes', 'No timecodes generated')}"
+            
+            # Telegram message limit
+            if len(timecodes_text) > 4000:
+                timecodes_text = timecodes_text[:4000] + "...\n\n*Timecodes truncated due to length*"
+            
+            # Add back button
+            keyboard = [[InlineKeyboardButton("⬅️ Back", callback_data=f"back:{url}")]]
+            reply_markup = InlineKeyboardMarkup(keyboard)
+            
+            await query.edit_message_text(timecodes_text, reply_markup=reply_markup, parse_mode=ParseMode.MARKDOWN)
+            
+        except Exception as e:
+            logger.error(f"Error generating timecodes: {e}")
+            await query.edit_message_text("❌ An error occurred while generating timecodes.")
+    
+    async def handle_search_callback(self, query, search_query: str):
+        """Handle search from callback"""
+        await query.edit_message_text(f"🔍 Searching for: *{search_query}*", parse_mode=ParseMode.MARKDOWN)
+        
+        # Simulate update object for reuse of search logic
+        class FakeUpdate:
+            def __init__(self, message):
+                self.message = message
+        
+        fake_update = FakeUpdate(query.message)
+        await self.handle_search(fake_update, search_query)
+    
+    async def call_mcp_action(self, action: str, params: dict) -> Optional[dict]:
+        """Call MCP server action"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                payload = {
+                    "action": action,
+                    "parameters": params
+                }
+                
+                async with session.post(MCP_BASE_URL, json=payload, timeout=30) as response:
+                    if response.status == 200:
+                        return await response.json()
+                    else:
+                        logger.error(f"MCP server error: {response.status}")
+                        return None
+        except Exception as e:
+            logger.error(f"Error calling MCP server: {e}")
+            return None
+    
+    def format_video_info(self, video_info: dict) -> str:
+        """Format video information for display"""
+        title = video_info.get("title", "Unknown Title")
+        channel = video_info.get("channel", "Unknown Channel")
+        duration = video_info.get("duration", "Unknown")
+        view_count = video_info.get("view_count", "Unknown")
+        upload_date = video_info.get("upload_date", "Unknown")
+        description = video_info.get("description", "")
+        
+        # Truncate description if too long
+        if len(description) > 200:
+            description = description[:200] + "..."
+        
+        info_text = f"""🎬 **{title}**
+
+👤 **Channel:** {channel}
+⏱️ **Duration:** {duration}
+👁️ **Views:** {view_count}
+📅 **Uploaded:** {upload_date}
+
+📝 **Description:**
+{description}
+
+Choose an action below:"""
+        
+        return info_text
+    
+    async def run(self):
+        """Start the bot"""
+        logger.info("Starting TubeMeta Bot...")
+        await self.app.initialize()
+        await self.app.start()
+        await self.app.updater.start_polling()
+        
+        try:
+            # Keep the bot running
+            await asyncio.Event().wait()
+        except KeyboardInterrupt:
+            logger.info("Shutting down bot...")
+        finally:
+            await self.app.updater.stop()
+            await self.app.stop()
+            await self.app.shutdown()
+
+async def main():
+    """Main function"""
+    bot = TubeMetaBot()
+    await bot.run()
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

telegram_requirements.txt

@@ -0,0 +1,3 @@
+python-telegram-bot>=21.0
+aiohttp>=3.10.0
+python-dotenv>=1.0.0 

update_server.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Скрипт для обновления сервера после git push
+
+echo "🔄 Обновление сервера..."
+
+# 1. Остановка текущих процессов
+echo "⏹️ Остановка текущих процессов..."
+pkill -f "main.py" || echo "MCP сервер не был запущен"
+pkill -f "run_telegram_bot.py" || echo "Telegram бот не был запущен"
+
+# 2. Обновление кода
+echo "📥 Получение последних изменений..."
+git pull
+
+# 3. Проверка и установка зависимостей
+echo "📦 Проверка зависимостей..."
+pip install -r requirements.txt --quiet
+pip install -r telegram_requirements.txt --quiet
+
+# 4. Запуск MCP сервера в фоне
+echo "🚀 Запуск MCP сервера..."
+nohup python main.py --mode api --host 0.0.0.0 --port 8080 > mcp_server.log 2>&1 &
+MCP_PID=$!
+echo "MCP сервер запущен с PID: $MCP_PID"
+
+# 5. Ждем 3 секунды для запуска MCP сервера
+sleep 3
+
+# 6. Запуск Telegram бота в фоне
+echo "🤖 Запуск Telegram бота..."
+nohup python run_telegram_bot.py > telegram_bot.log 2>&1 &
+BOT_PID=$!
+echo "Telegram бот запущен с PID: $BOT_PID"
+
+echo "✅ Сервер обновлен и перезапущен!"
+echo "📋 Процессы:"
+echo "  MCP сервер PID: $MCP_PID"
+echo "  Telegram бот PID: $BOT_PID"
+echo ""
+echo "📊 Для просмотра логов:"
+echo "  MCP сервер: tail -f mcp_server.log"
+echo "  Telegram бот: tail -f telegram_bot.log" 

update_tunnel.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+"""
+Script to update MCP server URL when LocalTunnel changes
+Usage: python update_tunnel.py <new_tunnel_url>
+"""
+
+import sys
+import re
+
+def update_tunnel_url(new_url):
+    """Update the MCP_BASE_URL in telegram_config.env"""
+    
+    # Validate URL format
+    if not new_url.startswith('https://') or '.loca.lt' not in new_url:
+        print("❌ Invalid URL format. Expected: https://xxx.loca.lt")
+        return False
+    
+    # Add /api/mcp if not present
+    if not new_url.endswith('/api/mcp'):
+        if new_url.endswith('/'):
+            new_url = new_url + 'api/mcp'
+        else:
+            new_url = new_url + '/api/mcp'
+    
+    try:
+        # Read current config
+        with open('telegram_config.env', 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # Update MCP_BASE_URL
+        updated_content = re.sub(
+            r'MCP_BASE_URL=.*',
+            f'MCP_BASE_URL={new_url}',
+            content
+        )
+        
+        # Write back
+        with open('telegram_config.env', 'w', encoding='utf-8') as f:
+            f.write(updated_content)
+        
+        print(f"✅ Updated MCP_BASE_URL to: {new_url}")
+        print("🔄 Please restart the Telegram bot to apply changes")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error updating config: {e}")
+        return False
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python update_tunnel.py <new_tunnel_url>")
+        print("Example: python update_tunnel.py https://abc-def-ghi.loca.lt")
+        sys.exit(1)
+    
+    new_url = sys.argv[1]
+    update_tunnel_url(new_url)