Add multi-agent coach system (FAISS files to be uploaded separately)

.gitattributes

@@ -3,6 +3,7 @@
 *.bin filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
 *.ckpt filter=lfs diff=lfs merge=lfs -text
+*.faiss filter=lfs diff=lfs merge=lfs -text
 *.ftz filter=lfs diff=lfs merge=lfs -text
 *.gz filter=lfs diff=lfs merge=lfs -text
 *.h5 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,54 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+
+# Environment variables
+.env
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+logs/
+*.log
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Temporary files
+*.tmp
+*.bak
+knowledge_base/faiss_index/*.faiss

PUSH_INSTRUCTIONS.md

@@ -0,0 +1,79 @@
+# ✅ YOUR FILES ARE READY TO PUSH!
+
+All necessary files have been copied to:
+`/Users/ralitzamondal/Documents/LolMultiAgent/`
+
+## 📦 Files Successfully Copied:
+
+✅ app.py (HF entry point)
+✅ multi_agent_coach.py (Main system - 60KB)
+✅ specialized_agents.py (Agents)
+✅ riot_api.py (Riot API)
+✅ youtube_scraper.py (YouTube)
+✅ requirements.txt (Dependencies)
+✅ README.md (HF documentation)
+✅ .gitignore (Git rules)
+✅ knowledge_base/faiss_index/index.faiss (202KB)
+✅ knowledge_base/faiss_index/index.pkl (14KB)
+
+## 🔐 Next Step: Push to Hugging Face
+
+You need to authenticate with Hugging Face using a token:
+
+### Option 1: Use Hugging Face CLI (Recommended)
+
+```bash
+cd /Users/ralitzamondal/Documents/LolMultiAgent
+/Users/ralitzamondal/Documents/lol-coach-agent/venv/bin/huggingface-cli login
+# Enter your token when prompted
+git push
+```
+
+### Option 2: Use Git with Token
+
+```bash
+cd /Users/ralitzamondal/Documents/LolMultiAgent
+git remote set-url origin https://YOUR_USERNAME:YOUR_TOKEN@huggingface.co/spaces/Ralitza1/LolMultiAgent
+git push
+```
+
+### Where to Get Your Token:
+
+1. Go to https://huggingface.co/settings/tokens
+2. Click "New token"
+3. Name: "LolMultiAgent"
+4. Type: "Write" (to push code)
+5. Copy the token
+
+## 🚀 After Pushing:
+
+1. Go to https://huggingface.co/spaces/Ralitza1/LolMultiAgent
+2. Wait 5-10 minutes for build
+3. Add API keys in Settings → Repository Secrets:
+   - OPENAI_API_KEY
+   - RIOT_API_KEY
+   - TAVILY_API_KEY
+4. Your Space will be live!
+
+## 📋 Quick Push Commands:
+
+```bash
+cd /Users/ralitzamondal/Documents/LolMultiAgent
+
+# Login to Hugging Face (do this once)
+/Users/ralitzamondal/Documents/lol-coach-agent/venv/bin/huggingface-cli login
+
+# Push to Hugging Face
+git push
+
+# If it asks for credentials again, use your HF token as password
+```
+
+## ⚠️ Current Status:
+
+Your local changes are committed but NOT yet pushed to Hugging Face.
+You need to authenticate and push to make them live.
+
+---
+
+**All files are ready! Just need to push! 🎉**

README.md

@@ -1,14 +1,59 @@
 ---
-title: LolMultiAgent
-emoji: 🚀
-colorFrom: purple
-colorTo: pink
+title: LoL Multi-Agent Coach
+emoji: 🎮
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 6.3.0
-app_file: app.py
+sdk_version: "6.2.0"
+app_file: multi_agent_coach.py
 pinned: false
 license: mit
-short_description: This app will help you with play better at league of legends
+short_description: AI-powered League of Legends coaching system
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# League of Legends Multi-Agent Coach 🎮
+
+A sophisticated multi-agent AI coaching system for League of Legends that provides:
+- 🎯 Match analysis and performance insights
+- 🛠️ Build recommendations with real-time meta data
+- 🎬 Video guides and educational content
+- 📚 LoL knowledge base with FAISS vector search
+- 🎲 Pregame strategy (bans, picks, team comp analysis)
+
+## Features
+
+- **5 Specialized AI Agents** working collaboratively
+- **14 Tools** for comprehensive coaching
+- **Real-time data** from Riot API, Tavily, and YouTube
+- **FAISS Vector Database** for knowledge retrieval
+
+## Setup
+
+This Space requires three API keys to be set as Secrets:
+
+1. **OPENAI_API_KEY** - Get from https://platform.openai.com/
+2. **RIOT_API_KEY** - Get from https://developer.riotgames.com/
+3. **TAVILY_API_KEY** - Get from https://tavily.com/
+
+Optional: Configure your summoner information:
+- **SUMMONER_NAME** - Your League summoner name
+- **SUMMONER_TAG** - Your tagline (e.g., NA1)
+- **REGION** - Your region (e.g., na1)
+
+## Usage
+
+Simply type your questions in the chat interface:
+- "Analyze my last 5 games"
+- "What's the best build for Yasuo?"
+- "Find Yasuo vs Zed matchup videos"
+- "What should I ban if playing mid?"
+- "Analyze this team comp: Darius, Lee Sin, Ahri, Jinx, Thresh"
+
+## Technology Stack
+
+- **LangChain/LangGraph** - Multi-agent framework
+- **OpenAI GPT-4** - Language model
+- **Gradio 6.2.0** - Web interface
+- **FAISS** - Vector database
+- **Riot API** - Live game data
+- **Tavily** - Real-time web search

app.py

@@ -0,0 +1,35 @@
+"""
+League of Legends Multi-Agent Coach - Hugging Face Spaces Version
+This is a wrapper for deploying to Hugging Face Spaces.
+"""
+
+import os
+import sys
+
+# Set environment variables from Hugging Face Secrets
+# These will be available in the Hugging Face Spaces settings
+if not os.getenv("OPENAI_API_KEY"):
+    print("⚠️ WARNING: OPENAI_API_KEY not found in environment!")
+if not os.getenv("RIOT_API_KEY"):
+    print("⚠️ WARNING: RIOT_API_KEY not found in environment!")
+if not os.getenv("TAVILY_API_KEY"):
+    print("⚠️ WARNING: TAVILY_API_KEY not found in environment!")
+
+# Import the main application
+from multi_agent_coach import create_multi_agent_coach, create_gradio_interface
+
+# Create the coach system
+print("🚀 Initializing Multi-Agent LoL Coach System for Hugging Face...")
+coach = create_multi_agent_coach()
+
+# Create the Gradio interface
+print("🎨 Creating Gradio interface...")
+demo = create_gradio_interface(coach)
+
+# Launch with Hugging Face-compatible settings
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",  # Required for Hugging Face Spaces
+        server_port=7860,
+        share=False  # Not needed on HF Spaces
+    )

multi_agent_coach.py

@@ -0,0 +1,1315 @@
+"""
+Multi-Agent LoL Coach System
+Main integration file connecting router, agents, and orchestrator.
+"""
+
+import os
+import logging
+from datetime import datetime
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
+from langchain.tools import tool
+from langchain_community.vectorstores import FAISS
+from tavily import TavilyClient
+
+# Import API clients and data fetchers
+from riot_api import RiotAPI
+from data_fetchers import get_optimal_build_ugg, get_champion_stats
+from youtube_scraper import YouTubeScraper
+
+# Import multi-agent components
+from multi_agent_router import create_router, QueryRouter
+from specialized_agents import create_specialized_agents, BaseLoLAgent
+from multi_agent_orchestrator import create_orchestrator, MultiAgentOrchestrator
+
+# Create logs directory if it doesn't exist
+log_dir = os.path.join(os.path.dirname(__file__), 'logs')
+os.makedirs(log_dir, exist_ok=True)
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(log_dir, f'multi_agent_{datetime.now().strftime("%Y%m%d")}.log')),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+
+def load_knowledge_base_retriever(openai_api_key: str):
+    """
+    Load the LoL knowledge base FAISS vector store as a retriever.
+    
+    Args:
+        openai_api_key: OpenAI API key for embeddings
+        
+    Returns:
+        FAISS retriever or None if knowledge base doesn't exist
+    """
+    embeddings = OpenAIEmbeddings(api_key=openai_api_key)
+    
+    knowledge_base_path = "./knowledge_base/faiss_index"
+    if os.path.exists(knowledge_base_path):
+        logger.info(f"Loading FAISS knowledge base from {knowledge_base_path}")
+        try:
+            vector_store = FAISS.load_local(
+                knowledge_base_path,
+                embeddings,
+                allow_dangerous_deserialization=True
+            )
+            retriever = vector_store.as_retriever(search_kwargs={"k": 5})
+            logger.info("✅ FAISS knowledge base loaded successfully")
+            return retriever
+        except Exception as e:
+            logger.error(f"❌ Error loading FAISS knowledge base: {e}")
+            return None
+    else:
+        logger.warning(f"⚠️  Knowledge base not found at {knowledge_base_path}")
+        logger.warning("   Run 'python create_lol_knowledge_base.py' to create it")
+        return None
+
+
+# Import existing tools (from original lol_coach_agent.py)
+# These will be distributed among specialized agents
+
+
+class MultiAgentLoLCoach:
+    """
+    Multi-agent League of Legends coaching system with intelligent routing.
+    """
+    
+    def __init__(
+        self,
+        openai_api_key: str,
+        riot_api_key: str,
+        region: str = "na1",
+        routing_value: str = "americas",
+        summoner_name: str = None,
+        summoner_tag: str = None,
+        additional_summoners: list = None
+    ):
+        # Initialize LLM
+        self.llm = ChatOpenAI(
+            api_key=openai_api_key,
+            model="gpt-4o-mini",
+            temperature=0.3
+        )
+        
+        # Store API keys and user info for tools
+        self.riot_api_key = riot_api_key
+        self.region = region
+        self.routing_value = routing_value
+        self.summoner_name = summoner_name
+        self.summoner_tag = summoner_tag
+        self.additional_summoners = additional_summoners or []
+        
+        # Initialize API clients
+        self.riot_api = RiotAPI(api_key=riot_api_key, region=region, routing=routing_value)
+        self.youtube_scraper = YouTubeScraper()
+        
+        # Initialize Tavily client for web search
+        tavily_api_key = os.getenv("TAVILY_API_KEY")
+        self.tavily_client = TavilyClient(api_key=tavily_api_key) if tavily_api_key else None
+        
+        # Initialize components
+        logger.info("Initializing Multi-Agent LoL Coach System...")
+        print("🚀 Initializing Multi-Agent LoL Coach System...")
+        
+        # Load FAISS knowledge base
+        self.knowledge_retriever = load_knowledge_base_retriever(openai_api_key)
+        if self.knowledge_retriever:
+            print("   ✅ FAISS knowledge base loaded")
+        else:
+            print("   ⚠️  FAISS knowledge base not available")
+        
+        # Display tracked summoners
+        if summoner_name and summoner_tag:
+            primary_summoner = f"{summoner_name}#{summoner_tag}"
+            logger.info(f"Primary Summoner: {primary_summoner} ({region.upper()})")
+            print(f"   👤 Primary Summoner: {primary_summoner} ({region.upper()})")
+            
+            if additional_summoners:
+                logger.info(f"Additional Summoners: {', '.join(additional_summoners)}")
+                print(f"   👥 Additional Summoners: {', '.join(additional_summoners)}")
+        
+        # 1. Create router
+        self.router = create_router(openai_api_key)
+        logger.info("Router initialized successfully")
+        print("   ✅ Router initialized")
+        
+        # 2. Organize tools by category
+        tools = self._organize_tools()
+        
+        # 3. Create specialized agents
+        self.agents = create_specialized_agents(self.llm, tools)
+        logger.info(f"{len(self.agents)} specialized agents created")
+        print(f"   ✅ {len(self.agents)} specialized agents created:")
+        for name, agent in self.agents.items():
+            info = agent.get_info()
+            print(f"      • {name}: {info['tool_count']} tools")
+        
+        # 4. Create orchestrator
+        self.orchestrator = create_orchestrator(self.llm, self.agents)
+        print("   ✅ Orchestrator initialized")
+        
+        print("\n✨ Multi-Agent System Ready!\n")
+    
+    def _organize_tools(self) -> dict:
+        """
+        Organize all tools into categories for distribution to specialized agents.
+        
+        Note: This imports tools from the original lol_coach_agent.py
+        We'll need to refactor those tools to be importable.
+        """
+        # Helper function to get tagline for summoner
+        def get_tagline_for_summoner(summoner_name: str) -> str:
+            """Look up the correct tagline for a summoner name."""
+            summoner_name_lower = summoner_name.lower()
+            tracked_summoners = [(self.summoner_name, self.summoner_tag)]
+            for summoner in self.additional_summoners:
+                if "#" in summoner:
+                    name, tag = summoner.split("#", 1)
+                    tracked_summoners.append((name.strip(), tag.strip()))
+            
+            for name, tag in tracked_summoners:
+                if name.lower() == summoner_name_lower:
+                    return tag
+            return self.summoner_tag or "NA1"
+        
+        # === MATCH ANALYSIS TOOLS ===
+        match_tools = []
+        
+        @tool
+        def get_summoner_profile(summoner_name: str = None, tag_line: str = None) -> str:
+            """
+            Get summoner profile information including level, rank, and basic stats.
+            If no summoner_name provided, uses the configured default summoner.
+            """
+            if summoner_name is None:
+                summoner_name = self.summoner_name
+            if tag_line is None:
+                tag_line = get_tagline_for_summoner(summoner_name)
+            
+            try:
+                account_info = self.riot_api.get_account_by_riot_id(summoner_name, tag_line)
+                if not account_info:
+                    return f"❌ Account '{summoner_name}#{tag_line}' not found."
+                
+                puuid = account_info.get('puuid')
+                summoner_info = self.riot_api.get_summoner_by_puuid(puuid)
+                
+                if not summoner_info or 'id' not in summoner_info:
+                    return f"❌ Summoner data not found for '{summoner_name}#{tag_line}'."
+                
+                ranked_info = self.riot_api.get_ranked_stats(summoner_info.get('id'))
+                
+                result = f"📊 **Summoner Profile: {summoner_name}#{tag_line}**\n\n"
+                result += f"• Level: {summoner_info.get('summonerLevel', 'N/A')}\n\n"
+                
+                if ranked_info:
+                    for queue in ranked_info:
+                        queue_type = queue.get('queueType', 'Unknown')
+                        tier = queue.get('tier', 'Unranked')
+                        rank = queue.get('rank', '')
+                        lp = queue.get('leaguePoints', 0)
+                        wins = queue.get('wins', 0)
+                        losses = queue.get('losses', 0)
+                        win_rate = (wins / (wins + losses) * 100) if (wins + losses) > 0 else 0
+                        
+                        result += f"**{queue_type}**\n"
+                        result += f"• Rank: {tier} {rank} ({lp} LP)\n"
+                        result += f"• Win Rate: {wins}W / {losses}L ({win_rate:.1f}%)\n\n"
+                else:
+                    result += "• No ranked data available\n"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error fetching summoner profile: {e}")
+                return f"❌ Error fetching summoner profile: {str(e)}"
+        
+        match_tools.append(get_summoner_profile)
+        
+        @tool
+        def analyze_recent_matches(summoner_name: str = None, tag_line: str = None, num_matches: int = 10) -> str:
+            """
+            Analyze recent match history and provide performance insights.
+            Shows KDA, win rate, CS, damage, and identifies patterns.
+            """
+            if summoner_name is None:
+                summoner_name = self.summoner_name
+            if tag_line is None:
+                tag_line = get_tagline_for_summoner(summoner_name)
+            
+            try:
+                account_info = self.riot_api.get_account_by_riot_id(summoner_name, tag_line)
+                if not account_info:
+                    return f"❌ Account '{summoner_name}#{tag_line}' not found."
+                
+                puuid = account_info.get('puuid')
+                match_ids = self.riot_api.get_match_history(puuid, count=num_matches)
+                
+                if not match_ids:
+                    return "❌ No match history found."
+                
+                matches_data = []
+                for match_id in match_ids[:num_matches]:
+                    match_detail = self.riot_api.get_match_details(match_id, puuid)
+                    if match_detail:
+                        matches_data.append(match_detail)
+                
+                if not matches_data:
+                    return "❌ Could not retrieve match details."
+                
+                # Calculate statistics
+                total_games = len(matches_data)
+                wins = sum(1 for m in matches_data if m['win'])
+                win_rate = (wins / total_games * 100) if total_games > 0 else 0
+                
+                avg_kills = sum(m['kills'] for m in matches_data) / total_games
+                avg_deaths = sum(m['deaths'] for m in matches_data) / total_games
+                avg_assists = sum(m['assists'] for m in matches_data) / total_games
+                avg_kda = ((avg_kills + avg_assists) / avg_deaths) if avg_deaths > 0 else 0
+                
+                avg_cs = sum(m['cs'] for m in matches_data) / total_games
+                avg_damage = sum(m['damage'] for m in matches_data) / total_games
+                
+                # Champion frequency
+                champion_counts = {}
+                for match in matches_data:
+                    champ = match['champion']
+                    if champ not in champion_counts:
+                        champion_counts[champ] = {'games': 0, 'wins': 0}
+                    champion_counts[champ]['games'] += 1
+                    if match['win']:
+                        champion_counts[champ]['wins'] += 1
+                
+                result = f"🎮 **Match Analysis: Last {total_games} Games**\n\n"
+                result += f"**Overall Performance:**\n"
+                result += f"• Win Rate: {wins}W / {total_games - wins}L ({win_rate:.1f}%)\n"
+                result += f"• Average KDA: {avg_kills:.1f} / {avg_deaths:.1f} / {avg_assists:.1f} ({avg_kda:.2f} ratio)\n"
+                result += f"• Average CS: {avg_cs:.0f}\n"
+                result += f"• Average Damage: {avg_damage:,.0f}\n\n"
+                
+                result += "**Champion Pool:**\n"
+                for champ, stats in sorted(champion_counts.items(), key=lambda x: x[1]['games'], reverse=True):
+                    champ_wr = (stats['wins'] / stats['games'] * 100) if stats['games'] > 0 else 0
+                    result += f"• {champ}: {stats['games']} games, {stats['wins']}W ({champ_wr:.0f}% WR)\n"
+                
+                result += "\n**Recent Matches:**\n"
+                for i, match in enumerate(matches_data[:5], 1):
+                    result_icon = "✅" if match['win'] else "❌"
+                    kda = f"{match['kills']}/{match['deaths']}/{match['assists']}"
+                    result += f"{i}. {result_icon} {match['champion']} - {kda} - {match['cs']} CS\n"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error analyzing matches: {e}")
+                return f"❌ Error analyzing matches: {str(e)}"
+        
+        match_tools.append(analyze_recent_matches)
+        
+        # === KNOWLEDGE BASE TOOLS ===
+        knowledge_tools = []
+        
+        # Add FAISS knowledge base search
+        if self.knowledge_retriever:
+            @tool
+            def search_lol_knowledge(query: str) -> str:
+                """
+                Search the League of Legends knowledge base for information about champions,
+                items, runes, game mechanics, strategies, and meta information.
+                """
+                try:
+                    docs = self.knowledge_retriever.invoke(query)
+                    if docs:
+                        results = []
+                        for i, doc in enumerate(docs, 1):
+                            results.append(f"[Source {i}]\n{doc.page_content}\n")
+                        return "\n".join(results)
+                    else:
+                        return "No relevant information found in the knowledge base."
+                except Exception as e:
+                    logger.error(f"Error searching knowledge base: {e}")
+                    return f"Error searching knowledge base: {str(e)}"
+            
+            knowledge_tools.append(search_lol_knowledge)
+        
+        # Add Tavily web search for real-time LoL information
+        if self.tavily_client:
+            @tool
+            def search_web_lol_info(query: str) -> str:
+                """
+                Search the web for real-time League of Legends information including:
+                - Current meta analysis and tier lists
+                - Latest patch notes and balance changes
+                - Pro player builds and strategies
+                - Champion guides from popular sites
+                - Recent tournament results
+                
+                Use this for up-to-date information that may not be in the knowledge base.
+                """
+                try:
+                    # Add "League of Legends" to the query for better results
+                    search_query = f"League of Legends {query}"
+                    logger.info(f"Tavily search: {search_query}")
+                    
+                    response = self.tavily_client.search(
+                        query=search_query,
+                        search_depth="advanced",
+                        max_results=5
+                    )
+                    
+                    if not response or 'results' not in response:
+                        return "❌ No web results found."
+                    
+                    results = []
+                    for i, result in enumerate(response['results'][:5], 1):
+                        title = result.get('title', 'No title')
+                        content = result.get('content', 'No content')
+                        url = result.get('url', 'No URL')
+                        
+                        results.append(f"**[{i}] {title}**\n{content}\n🔗 Source: {url}\n")
+                    
+                    if results:
+                        return "🌐 **Web Search Results:**\n\n" + "\n".join(results)
+                    else:
+                        return "❌ No relevant web results found."
+                        
+                except Exception as e:
+                    logger.error(f"Error searching web with Tavily: {e}")
+                    return f"❌ Error searching web: {str(e)}"
+            
+            knowledge_tools.append(search_web_lol_info)
+        
+        # === VIDEO GUIDE TOOLS ===
+        video_tools = []
+        
+        @tool
+        def find_champion_guides(champion_name: str, max_results: int = 5) -> str:
+            """
+            Find YouTube video guides for a specific champion.
+            Returns video titles, channels, durations, and links to helpful guides.
+            """
+            try:
+                query = f"League of Legends {champion_name} guide season 14 2024"
+                videos = self.youtube_scraper.search_videos(query, max_results)
+                
+                if not videos:
+                    return f"❌ No guide videos found for {champion_name}."
+                
+                result = f"🎬 **YouTube Guides for {champion_name}**\n\n"
+                result += f"Found {len(videos)} helpful guides:\n\n"
+                result += self.youtube_scraper.format_video_list(videos)
+                result += "\n💡 **Tip:** Watch these guides to learn optimal combos, positioning, and decision-making!"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error finding champion guides: {e}")
+                return f"❌ Error finding champion guides: {str(e)}"
+        
+        video_tools.append(find_champion_guides)
+        
+        @tool
+        def find_matchup_videos(champion_name: str, enemy_champion: str, max_results: int = 3) -> str:
+            """
+            Find YouTube videos showing how to play a specific matchup.
+            Shows real gameplay examples of your champion vs enemy champion.
+            """
+            try:
+                query = f"League of Legends {champion_name} vs {enemy_champion} matchup guide"
+                videos = self.youtube_scraper.search_videos(query, max_results)
+                
+                if not videos:
+                    return f"❌ No matchup videos found for {champion_name} vs {enemy_champion}."
+                
+                result = f"⚔️ **{champion_name} vs {enemy_champion} - Matchup Videos**\n\n"
+                result += f"Watch these to learn how to play this matchup:\n\n"
+                result += self.youtube_scraper.format_video_list(videos)
+                result += f"\n💡 **Watch for:** Trading patterns, wave management, powerspikes, and how to exploit {enemy_champion}'s weaknesses"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error finding matchup videos: {e}")
+                return f"❌ Error finding matchup videos: {str(e)}"
+        
+        video_tools.append(find_matchup_videos)
+        
+        @tool
+        def find_educational_videos(topic: str, max_results: int = 5) -> str:
+            """
+            Find educational League of Legends videos on a specific topic.
+            Topics can include: wave management, trading, macro, team fighting, vision control, etc.
+            """
+            try:
+                query = f"League of Legends {topic} guide tutorial"
+                videos = self.youtube_scraper.search_videos(query, max_results)
+                
+                if not videos:
+                    return f"❌ No educational videos found for '{topic}'."
+                
+                result = f"📚 **Learning Resources: {topic}**\n\n"
+                result += self.youtube_scraper.format_video_list(videos)
+                result += f"\n🎓 **Study tip:** Take notes while watching and practice these concepts in your next games!"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error finding educational videos: {e}")
+                return f"❌ Error finding educational videos: {str(e)}"
+        
+        video_tools.append(find_educational_videos)
+        
+        # === BUILD ADVISOR TOOLS ===
+        build_tools = []
+        
+        @tool
+        def get_optimal_build(champion_name: str, role: str = "any", enemy_matchup: str = None) -> str:
+            """
+            Get optimal item build, runes, and skill order for a champion based on current meta.
+            Uses real-time data from Tavily to find the best builds being used by high-elo players.
+            """
+            try:
+                if not self.tavily_client:
+                    return "❌ Tavily API not configured. Cannot fetch build recommendations."
+                
+                # Build search query
+                query = f"{champion_name} {role} build items runes skill order season 14 2024 high elo pro"
+                if enemy_matchup:
+                    query += f" vs {enemy_matchup}"
+                
+                logger.info(f"Fetching optimal build: {query}")
+                
+                response = self.tavily_client.search(
+                    query=query,
+                    search_depth="advanced",
+                    max_results=5
+                )
+                
+                if not response or 'results' not in response:
+                    return f"❌ Could not find build information for {champion_name}."
+                
+                result = f"🛠️ **Optimal Build for {champion_name}**"
+                if role and role != "any":
+                    result += f" ({role.capitalize()})"
+                if enemy_matchup:
+                    result += f" vs {enemy_matchup}"
+                result += "\n\n"
+                
+                result += "**Current Meta Build Information:**\n\n"
+                for i, item in enumerate(response['results'][:3], 1):
+                    result += f"{i}. **{item['title']}**\n"
+                    result += f"   {item['content'][:250]}...\n"
+                    result += f"   🔗 Source: {item['url']}\n\n"
+                
+                result += "💡 **Tip:** Look for common patterns across sources - consistent recommendations indicate proven strategies!"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error fetching optimal build: {e}")
+                return f"❌ Error fetching build: {str(e)}"
+        
+        build_tools.append(get_optimal_build)
+        
+        @tool
+        def get_champion_matchups(champion_name: str) -> str:
+            """
+            Get matchup information including counters, favorable matchups, and tips.
+            Uses real-time data to find current meta matchup analysis.
+            """
+            try:
+                if not self.tavily_client:
+                    return "❌ Tavily API not configured. Cannot fetch matchup data."
+                
+                query = f"{champion_name} counters matchups tier list strong against weak against"
+                logger.info(f"Fetching matchup data: {query}")
+                
+                response = self.tavily_client.search(
+                    query=query,
+                    search_depth="advanced",
+                    max_results=5
+                )
+                
+                if not response or 'results' not in response:
+                    return f"❌ Could not find matchup information for {champion_name}."
+                
+                result = f"⚔️ **{champion_name} Matchup Analysis**\n\n"
+                result += "**Current Meta Analysis:**\n\n"
+                
+                for i, item in enumerate(response['results'][:3], 1):
+                    result += f"{i}. **{item['title']}**\n"
+                    result += f"   {item['content'][:250]}...\n"
+                    result += f"   🔗 {item['url']}\n\n"
+                
+                result += "💡 **Tip:** Study your hardest matchups and learn how pros play them!"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error fetching matchups: {e}")
+                return f"❌ Error fetching matchups: {str(e)}"
+        
+        build_tools.append(get_champion_matchups)
+        
+        @tool
+        def get_personalized_build_advice(champion_name: str, summoner_name: str = None) -> str:
+            """
+            Get personalized build recommendations based on the summoner's match history and playstyle.
+            Analyzes recent performance to suggest build adaptations.
+            """
+            try:
+                # Get summoner's recent matches to analyze playstyle
+                summoner_context = ""
+                if summoner_name or self.summoner_name:
+                    name = summoner_name or self.summoner_name
+                    tagline = self.get_tagline_for_summoner(name)
+                    
+                    logger.info(f"Analyzing {name}'s playstyle for personalized build")
+                    
+                    summoner_info = self.riot_api.get_summoner(name, tagline)
+                    if summoner_info and 'puuid' in summoner_info:
+                        matches = self.riot_api.get_match_history(summoner_info['puuid'], count=5)
+                        
+                        if matches:
+                            # Analyze playstyle from recent matches
+                            total_kills = 0
+                            total_deaths = 0
+                            total_damage = 0
+                            game_count = 0
+                            
+                            for match_id in matches[:5]:
+                                match_detail = self.riot_api.get_match_details(match_id, summoner_info['puuid'])
+                                if match_detail:
+                                    total_kills += match_detail.get('kills', 0)
+                                    total_deaths += match_detail.get('deaths', 0)
+                                    total_damage += match_detail.get('damage', 0)
+                                    game_count += 1
+                            
+                            if game_count > 0:
+                                avg_kda = ((total_kills) / total_deaths) if total_deaths > 0 else total_kills
+                                avg_damage = total_damage / game_count
+                                
+                                if avg_kda > 4:
+                                    summoner_context = f"\n**Your Playstyle:** Aggressive carry-style (KDA: {avg_kda:.1f}). Consider damage-focused builds."
+                                elif avg_kda < 2:
+                                    summoner_context = f"\n**Your Playstyle:** Struggling with deaths (KDA: {avg_kda:.1f}). Consider defensive/survivability items."
+                                else:
+                                    summoner_context = f"\n**Your Playstyle:** Balanced playstyle (KDA: {avg_kda:.1f}). Standard meta builds work well."
+                                
+                                if avg_damage > 20000:
+                                    summoner_context += f"\n**Damage Profile:** High damage dealer ({avg_damage:,.0f} avg). Keep prioritizing damage."
+                                elif avg_damage < 12000:
+                                    summoner_context += f"\n**Damage Profile:** Lower damage output ({avg_damage:,.0f} avg). Focus on damage items and positioning."
+                
+                # Get meta build with personalized context
+                if not self.tavily_client:
+                    return "❌ Tavily API not configured."
+                
+                query = f"{champion_name} build recommendations playstyle adaptations when ahead when behind"
+                logger.info(f"Fetching personalized build advice: {query}")
+                
+                response = self.tavily_client.search(
+                    query=query,
+                    search_depth="advanced",
+                    max_results=4
+                )
+                
+                result = f"🎯 **Personalized Build Advice for {champion_name}**\n"
+                result += summoner_context
+                result += "\n\n**Build Adaptations:**\n\n"
+                
+                if response and 'results' in response:
+                    for i, item in enumerate(response['results'][:3], 1):
+                        result += f"{i}. **{item['title']}**\n"
+                        result += f"   {item['content'][:200]}...\n"
+                        result += f"   🔗 {item['url']}\n\n"
+                
+                result += "\n💡 **Remember:** Adapt your build based on game state - build defensively when behind, offensively when ahead!"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error getting personalized build advice: {e}")
+                return f"❌ Error: {str(e)}"
+        
+        build_tools.append(get_personalized_build_advice)
+        
+        # === PREGAME STRATEGY TOOLS ===
+        pregame_tools = []
+        
+        @tool
+        def recommend_bans(enemy_picks: str = None, your_role: str = None) -> str:
+            """
+            Recommend champions to ban based on current meta and enemy team picks.
+            Helps you ban OP champions or counter enemy team composition.
+            
+            Args:
+                enemy_picks: Comma-separated list of champions enemy has already picked (optional)
+                your_role: Your intended role to ban lane counters (optional)
+            """
+            try:
+                if not self.tavily_client:
+                    return "❌ Tavily API not configured. Cannot fetch ban recommendations."
+                
+                # Build query based on context
+                query = "League of Legends season 14 2024 best bans meta OP champions tier list"
+                if enemy_picks:
+                    query += f" synergy with {enemy_picks}"
+                if your_role:
+                    query += f" {your_role} lane counters"
+                
+                logger.info(f"Fetching ban recommendations: {query}")
+                
+                response = self.tavily_client.search(
+                    query=query,
+                    search_depth="advanced",
+                    max_results=5
+                )
+                
+                if not response or 'results' not in response:
+                    return "❌ Could not fetch ban recommendations."
+                
+                result = "🚫 **Ban Recommendations**\n\n"
+                
+                if enemy_picks:
+                    result += f"**Enemy Picks:** {enemy_picks}\n"
+                if your_role:
+                    result += f"**Your Role:** {your_role}\n"
+                
+                result += "\n**Meta Analysis & Ban Priority:**\n\n"
+                
+                for i, item in enumerate(response['results'][:4], 1):
+                    result += f"{i}. **{item['title']}**\n"
+                    result += f"   {item['content'][:220]}...\n"
+                    result += f"   🔗 {item['url']}\n\n"
+                
+                result += "💡 **Ban Strategy Tips:**\n"
+                result += "• Ban champions that counter your main champion\n"
+                result += "• Ban meta OP champions with high win rates\n"
+                result += "• Ban champions that synergize well with enemy picks\n"
+                result += "• Consider banning champions your team struggles against"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error recommending bans: {e}")
+                return f"❌ Error: {str(e)}"
+        
+        pregame_tools.append(recommend_bans)
+        
+        @tool
+        def suggest_champion_pick(
+            role: str,
+            team_picks: str = None,
+            enemy_picks: str = None,
+            preferred_playstyle: str = None
+        ) -> str:
+            """
+            Suggest the best champion to pick for your role based on team composition and enemy picks.
+            
+            Args:
+                role: Your role (top, jungle, mid, adc, support)
+                team_picks: Comma-separated list of what your team has picked (optional)
+                enemy_picks: Comma-separated list of enemy team picks (optional)
+                preferred_playstyle: Your preferred playstyle (aggressive, defensive, utility, etc.)
+            """
+            try:
+                if not self.tavily_client:
+                    return "❌ Tavily API not configured."
+                
+                # Build comprehensive query
+                query = f"League of Legends best {role} champions season 14 2024"
+                
+                context_parts = []
+                if team_picks:
+                    context_parts.append(f"team composition {team_picks}")
+                if enemy_picks:
+                    context_parts.append(f"counter picks against {enemy_picks}")
+                if preferred_playstyle:
+                    context_parts.append(f"{preferred_playstyle} playstyle")
+                
+                if context_parts:
+                    query += " " + " ".join(context_parts)
+                
+                query += " meta tier list synergy"
+                
+                logger.info(f"Suggesting champion pick: {query}")
+                
+                response = self.tavily_client.search(
+                    query=query,
+                    search_depth="advanced",
+                    max_results=5
+                )
+                
+                if not response or 'results' not in response:
+                    return f"❌ Could not find champion recommendations for {role}."
+                
+                result = f"🎯 **Champion Pick Recommendation for {role.upper()}**\n\n"
+                
+                if team_picks:
+                    result += f"**Your Team:** {team_picks}\n"
+                if enemy_picks:
+                    result += f"**Enemy Team:** {enemy_picks}\n"
+                if preferred_playstyle:
+                    result += f"**Playstyle:** {preferred_playstyle}\n"
+                
+                result += "\n**Top Recommendations:**\n\n"
+                
+                for i, item in enumerate(response['results'][:4], 1):
+                    result += f"{i}. **{item['title']}**\n"
+                    result += f"   {item['content'][:220]}...\n"
+                    result += f"   🔗 {item['url']}\n\n"
+                
+                result += "💡 **Pick Strategy:**\n"
+                result += "✓ Pick champions that synergize with your team\n"
+                result += "✓ Pick counter-picks when possible\n"
+                result += "✓ Pick champions you're comfortable playing\n"
+                result += "✓ Consider team needs (AP/AD damage, tankiness, engage/disengage)"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error suggesting champion pick: {e}")
+                return f"❌ Error: {str(e)}"
+        
+        pregame_tools.append(suggest_champion_pick)
+        
+        @tool
+        def analyze_team_composition(
+            your_team: str,
+            enemy_team: str = None
+        ) -> str:
+            """
+            Analyze team composition to identify win conditions, strengths, weaknesses, and strategy.
+            
+            Args:
+                your_team: Comma-separated list of your team's champions (e.g., "Darius, Lee Sin, Ahri, Jinx, Thresh")
+                enemy_team: Comma-separated list of enemy champions (optional)
+            """
+            try:
+                if not self.tavily_client:
+                    return "❌ Tavily API not configured."
+                
+                # Analyze team comp
+                query = f"League of Legends team composition analysis {your_team}"
+                if enemy_team:
+                    query += f" vs {enemy_team} matchup"
+                query += " win condition strategy strengths weaknesses"
+                
+                logger.info(f"Analyzing team composition: {query}")
+                
+                response = self.tavily_client.search(
+                    query=query,
+                    search_depth="advanced",
+                    max_results=5
+                )
+                
+                result = f"📊 **Team Composition Analysis**\n\n"
+                result += f"**Your Team:** {your_team}\n"
+                if enemy_team:
+                    result += f"**Enemy Team:** {enemy_team}\n"
+                
+                result += "\n**Composition Analysis:**\n\n"
+                
+                if response and 'results' in response:
+                    for i, item in enumerate(response['results'][:3], 1):
+                        result += f"{i}. **{item['title']}**\n"
+                        result += f"   {item['content'][:220]}...\n"
+                        result += f"   🔗 {item['url']}\n\n"
+                
+                # Add basic analysis framework
+                result += "\n**Key Strategic Considerations:**\n\n"
+                result += "🎯 **Win Conditions:**\n"
+                result += "• Identify your team's power spikes (early/mid/late game)\n"
+                result += "• Determine primary win condition (team fights, split push, pick potential)\n\n"
+                
+                result += "💪 **Strengths to Leverage:**\n"
+                result += "• Team fight potential\n"
+                result += "• Engage/disengage capability\n"
+                result += "• Damage type balance (AP/AD/True)\n"
+                result += "• Tankiness and peel for carries\n\n"
+                
+                result += "⚠️ **Weaknesses to Cover:**\n"
+                result += "• Lack of engage or disengage\n"
+                result += "• Vulnerability to certain damage types\n"
+                result += "• Poor scaling or weak early game\n"
+                result += "• Limited crowd control\n\n"
+                
+                result += "📋 **Game Plan:**\n"
+                if enemy_team:
+                    result += "• Compare power spikes with enemy team\n"
+                    result += "• Identify favorable and unfavorable matchups\n"
+                result += "• Play to your strengths and cover weaknesses\n"
+                result += "• Coordinate objectives around your win condition"
+                
+                return result
+            except Exception as e:
+                logger.error(f"Error analyzing team composition: {e}")
+                return f"❌ Error: {str(e)}"
+        
+        pregame_tools.append(analyze_team_composition)
+        
+        @tool
+        def get_match_team_details(summoner_name: str = None, match_number: int = 1) -> str:
+            """
+            Get complete team composition details from a recent match, including all 10 players,
+            their champions, roles, and team assignments. Perfect for analyzing actual team comps.
+            
+            Args:
+                summoner_name: Summoner name to get match history from (uses primary summoner if not provided)
+                match_number: Which recent match to analyze (1 = most recent, 2 = second most recent, etc.)
+            """
+            try:
+                # Determine which summoner to use
+                name = summoner_name or self.summoner_name
+                if not name:
+                    return "❌ No summoner name provided and no default summoner configured."
+                
+                tagline = self.get_tagline_for_summoner(name)
+                logger.info(f"Fetching match team details for {name}#{tagline}, match #{match_number}")
+                
+                # Get summoner info
+                summoner_info = self.riot_api.get_summoner(name, tagline)
+                if not summoner_info or 'puuid' not in summoner_info:
+                    return f"❌ Could not find summoner: {name}#{tagline}"
+                
+                puuid = summoner_info['puuid']
+                
+                # Get match history
+                matches = self.riot_api.get_match_history(puuid, count=max(match_number, 5))
+                if not matches or len(matches) < match_number:
+                    return f"❌ Could not retrieve match #{match_number}. Only {len(matches) if matches else 0} matches available."
+                
+                # Get the specific match
+                match_id = matches[match_number - 1]
+                logger.info(f"Analyzing match: {match_id}")
+                
+                # Get full match data using Riot API (without puuid to get all participants)
+                match_data = self.riot_api.get_match_details(match_id)
+                if not match_data or 'info' not in match_data:
+                    return f"❌ Could not retrieve match data for match #{match_number}"
+                
+                info = match_data['info']
+                participants = info.get('participants', [])
+                
+                if not participants:
+                    return "❌ No participant data available for this match."
+                
+                # Find the summoner's team
+                summoner_team_id = None
+                for p in participants:
+                    if p.get('puuid') == puuid:
+                        summoner_team_id = p.get('teamId')
+                        break
+                
+                # Organize teams
+                blue_team = []
+                red_team = []
+                
+                for p in participants:
+                    player_info = {
+                        'name': f"{p.get('riotIdGameName', 'Unknown')}#{p.get('riotIdTagline', '')}",
+                        'champion': p.get('championName', 'Unknown'),
+                        'role': p.get('teamPosition', 'UNKNOWN').replace('UTILITY', 'SUPPORT'),
+                        'kills': p.get('kills', 0),
+                        'deaths': p.get('deaths', 0),
+                        'assists': p.get('assists', 0),
+                        'win': p.get('win', False)
+                    }
+                    
+                    if p.get('teamId') == 100:  # Blue side
+                        blue_team.append(player_info)
+                    else:  # Red side
+                        red_team.append(player_info)
+                
+                # Sort teams by role
+                role_order = {'TOP': 0, 'JUNGLE': 1, 'MIDDLE': 2, 'BOTTOM': 3, 'SUPPORT': 4, 'UNKNOWN': 5}
+                blue_team.sort(key=lambda x: role_order.get(x['role'], 5))
+                red_team.sort(key=lambda x: role_order.get(x['role'], 5))
+                
+                # Determine which team was yours
+                your_team_label = "Blue Team" if summoner_team_id == 100 else "Red Team"
+                enemy_team_label = "Red Team" if summoner_team_id == 100 else "Blue Team"
+                your_team = blue_team if summoner_team_id == 100 else red_team
+                enemy_team = red_team if summoner_team_id == 100 else blue_team
+                
+                match_result = "Victory" if your_team[0]['win'] else "Defeat"
+                
+                # Build result
+                result = f"🎮 **Match Team Composition - Match #{match_number}**\n\n"
+                result += f"**Match ID:** {match_id}\n"
+                result += f"**Result:** {match_result}\n"
+                result += f"**Summoner:** {name}#{tagline}\n\n"
+                
+                result += f"═══════════════════════════════════\n"
+                result += f"**{your_team_label} (Your Team)** {'✅' if your_team[0]['win'] else '❌'}\n"
+                result += f"═══════════════════════════════════\n"
+                for player in your_team:
+                    kda = f"{player['kills']}/{player['deaths']}/{player['assists']}"
+                    role_icon = {'TOP': '⬆️', 'JUNGLE': '🌲', 'MIDDLE': '⭐', 'BOTTOM': '🎯', 'SUPPORT': '🛡️'}.get(player['role'], '❓')
+                    result += f"{role_icon} **{player['role']}**: {player['champion']}\n"
+                    result += f"   Player: {player['name']} | KDA: {kda}\n"
+                
+                result += f"\n═══════════════════════════════════\n"
+                result += f"**{enemy_team_label} (Enemy Team)** {'✅' if enemy_team[0]['win'] else '❌'}\n"
+                result += f"═══════════════════════════════════\n"
+                for player in enemy_team:
+                    kda = f"{player['kills']}/{player['deaths']}/{player['assists']}"
+                    role_icon = {'TOP': '⬆️', 'JUNGLE': '🌲', 'MIDDLE': '⭐', 'BOTTOM': '🎯', 'SUPPORT': '🛡️'}.get(player['role'], '❓')
+                    result += f"{role_icon} **{player['role']}**: {player['champion']}\n"
+                    result += f"   Player: {player['name']} | KDA: {kda}\n"
+                
+                # Create composition strings for further analysis
+                your_champions = [p['champion'] for p in your_team]
+                enemy_champions = [p['champion'] for p in enemy_team]
+                
+                result += f"\n\n💡 **Team Composition Summary:**\n"
+                result += f"**Your Team:** {', '.join(your_champions)}\n"
+                result += f"**Enemy Team:** {', '.join(enemy_champions)}\n\n"
+                result += f"📊 You can now use `analyze_team_composition` with these exact teams for detailed strategic analysis!"
+                
+                return result
+                
+            except Exception as e:
+                logger.error(f"Error getting match team details: {e}")
+                return f"❌ Error retrieving match details: {str(e)}"
+        
+        pregame_tools.append(get_match_team_details)
+        
+        return {
+            "match": match_tools,      # get_summoner_profile, analyze_recent_matches
+            "build": build_tools,      # get_optimal_build, get_champion_matchups, get_personalized_build_advice
+            "video": video_tools,      # find_champion_guides, find_matchup_videos, find_educational_videos
+            "knowledge": knowledge_tools,  # search_lol_knowledge with FAISS, search_web_lol_info
+            "pregame": pregame_tools     # recommend_bans, suggest_champion_pick, analyze_team_composition
+        }
+    
+    def chat(self, user_message: str, thread_id: str = "default") -> str:
+        """
+        Handle a user message through the multi-agent system.
+        
+        Args:
+            user_message: User's question or request
+            thread_id: Conversation thread ID
+            
+        Returns:
+            Response from the appropriate agent(s)
+        """
+        logger.info(f"Processing user query: {user_message[:100]}...")
+        logger.info(f"Thread ID: {thread_id}")
+        
+        print("\n" + "=" * 80)
+        print(f"💬 User: {user_message}")
+        print("=" * 80)
+        
+        try:
+            # 1. Route the query
+            route = self.router.route(user_message)
+            logger.info(f"Query routed to: {route.agent}")
+            
+            # 2. Handle based on routing decision
+            if route.agent == "orchestrator" or route.needs_multiple_agents:
+                # Use orchestrator for complex queries
+                logger.info("Using orchestrator for multi-agent workflow")
+                response = self.orchestrator.handle_query(user_message, thread_id)
+            else:
+                # Direct to specific agent
+                agent = self.agents.get(route.agent)
+                if agent:
+                    agent_desc = self.router.get_agent_description(route.agent)
+                    print(f"\n{agent_desc}")
+                    logger.info(f"Invoking {route.agent}")
+                    response = agent.invoke(user_message, thread_id)
+                    logger.info(f"Agent {route.agent} completed successfully")
+                else:
+                    error_msg = f"Agent '{route.agent}' not found"
+                    logger.error(error_msg)
+                    response = f"❌ {error_msg}"
+        
+        except Exception as e:
+            logger.error(f"Error processing query: {str(e)}", exc_info=True)
+            response = self._handle_error(e, user_message)
+        
+        print("\n" + "=" * 80)
+        print("🤖 Response:")
+        print(response)
+        print("=" * 80 + "\n")
+        
+        logger.info(f"Response length: {len(response)} characters")
+        return response
+    
+    def _handle_error(self, error: Exception, query: str) -> str:
+        """
+        Handle errors gracefully with fallback responses.
+        
+        Args:
+            error: The exception that occurred
+            query: The original user query
+            
+        Returns:
+            User-friendly error message
+        """
+        error_type = type(error).__name__
+        logger.error(f"Error type: {error_type}, Query: {query[:100]}")
+        
+        # Check for specific error types
+        if "API" in str(error) or "api" in str(error).lower():
+            return ("⚠️ I'm having trouble connecting to the game data services right now. "
+                   "Please check your API keys and try again in a moment.")
+        
+        if "rate limit" in str(error).lower():
+            return ("⚠️ We've hit a rate limit. Please wait a moment and try again.")
+        
+        if "timeout" in str(error).lower():
+            return ("⚠️ The request took too long. Please try again with a simpler question.")
+        
+        # Generic fallback
+        return (f"❌ I encountered an error: {str(error)}\n\n"
+                f"💡 Try asking about:\n"
+                f"   • Match analysis: 'Analyze my recent games'\n"
+                f"   • Champion builds: 'What items should I build on [champion]?'\n"
+                f"   • Video guides: 'Find guides for [champion]'\n"
+                f"   • Game knowledge: 'What does [term] mean?'\n"
+                f"   • Pre-game strategy: 'Who should I ban?'")
+    
+    def _fallback_response(self, query: str) -> str:
+        """
+        Fallback response when routing fails or query is out of scope.
+        
+        Args:
+            query: The user's query
+            
+        Returns:
+            Helpful fallback message
+        """
+        logger.warning(f"Fallback triggered for query: {query[:100]}")
+        
+        return ("🤔 I'm not quite sure how to help with that specific question.\n\n"
+                "I specialize in:\n"
+                "   🎯 **Match Analysis** - Review your recent games and performance\n"
+                "   🛠️ **Build Advice** - Optimal items and runes for champions\n"
+                "   🎬 **Video Guides** - Find tutorials and gameplay videos\n"
+                "   📚 **Game Knowledge** - Explain League of Legends concepts\n"
+                "   🎯 **Pre-game Strategy** - Champion select, bans, and drafting\n\n"
+                "Try rephrasing your question or ask about one of these topics!")
+    
+    def get_system_info(self) -> dict:
+        """Get information about the multi-agent system."""
+        logger.debug("Retrieving system information")
+        return {
+            "agents": {
+                name: agent.get_info()
+                for name, agent in self.agents.items()
+            },
+            "router": "Active",
+            "orchestrator": "Active"
+        }
+
+
+def create_multi_agent_coach(
+    openai_api_key: str = None,
+    riot_api_key: str = None,
+    region: str = None,
+    routing_value: str = None,
+    summoner_name: str = None,
+    summoner_tag: str = None,
+    additional_summoners: str = None
+) -> MultiAgentLoLCoach:
+    """
+    Create a configured multi-agent LoL coach system.
+    
+    Args:
+        openai_api_key: OpenAI API key (loads from .env if not provided)
+        riot_api_key: Riot Games API key (loads from .env if not provided)
+        region: Riot API region (loads from .env if not provided)
+        routing_value: Riot API routing value (loads from .env if not provided)
+        summoner_name: Primary summoner name (loads from .env if not provided)
+        summoner_tag: Primary summoner tag (loads from .env if not provided)
+        additional_summoners: Comma-separated list of summoners (loads from .env if not provided)
+        
+    Returns:
+        Configured MultiAgentLoLCoach instance
+    """
+    load_dotenv()
+    
+    openai_api_key = openai_api_key or os.getenv("OPENAI_API_KEY")
+    riot_api_key = riot_api_key or os.getenv("RIOT_API_KEY")
+    region = region or os.getenv("REGION", "na1")
+    routing_value = routing_value or os.getenv("ROUTING_VALUE", "americas")
+    summoner_name = summoner_name or os.getenv("SUMMONER_NAME")
+    summoner_tag = summoner_tag or os.getenv("SUMMONER_TAG")
+    
+    # Parse additional summoners from comma-separated string
+    additional_summoners_str = additional_summoners or os.getenv("ADDITIONAL_SUMMONERS", "")
+    additional_summoners_list = [s.strip() for s in additional_summoners_str.split(",") if s.strip()]
+    
+    return MultiAgentLoLCoach(
+        openai_api_key=openai_api_key,
+        riot_api_key=riot_api_key,
+        region=region,
+        routing_value=routing_value,
+        summoner_name=summoner_name,
+        summoner_tag=summoner_tag,
+        additional_summoners=additional_summoners_list
+    )
+
+
+def create_gradio_interface(coach: MultiAgentLoLCoach):
+    """
+    Create a Gradio web interface for the multi-agent coach.
+    
+    Args:
+        coach: Configured MultiAgentLoLCoach instance
+        
+    Returns:
+        Gradio Blocks interface
+    """
+    import gradio as gr
+    
+    def chat_wrapper(message, history):
+        """Wrapper for Gradio chat interface"""
+        try:
+            # Use message directly for processing
+            response = coach.chat(message, "gradio_session")
+            return response
+        except Exception as e:
+            logger.error(f"Gradio chat error: {str(e)}", exc_info=True)
+            return f"❌ Error: {str(e)}\n\nPlease try again or rephrase your question."
+    
+    # Create Gradio interface
+    with gr.Blocks(title="⚔️ LoL Multi-Agent Coach") as demo:
+        gr.Markdown(
+            """
+            # ⚔️ League of Legends Multi-Agent Coach
+            ### AI-Powered Coaching with 5 Specialized Agents
+            
+            **Available Agents:**
+            - 🎯 **Pregame Agent** - Champion select, bans, draft strategy
+            - 🎯 **Match Analyzer** - Game history and performance analysis
+            - 🛠️ **Build Advisor** - Optimal items, runes, and champions
+            - 🎬 **Video Guide** - YouTube tutorials and gameplay videos
+            - 📚 **Knowledge Base** - Game concepts and terminology
+            
+            *The system automatically routes your question to the best agent(s)!*
+            """
+        )
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                chatbot = gr.Chatbot(
+                    height=500, 
+                    label="Multi-Agent Coach Chat",
+                    show_label=True
+                )
+                msg = gr.Textbox(
+                    label="Your Question",
+                    placeholder="E.g., 'Who should I ban?' or 'What items should I build on Ahri?'",
+                    lines=2
+                )
+                
+                with gr.Row():
+                    submit = gr.Button("Send", variant="primary", size="lg")
+                    clear = gr.Button("Clear Chat", size="lg")
+            
+            with gr.Column(scale=1):
+                gr.Markdown("### 💡 Example Questions")
+                examples = gr.Examples(
+                    examples=[
+                        "Who should I ban in ranked?",
+                        "What champion should I pick for mid lane?",
+                        "Analyze my recent matches",
+                        "What items should I build on Ahri?",
+                        "Find Yasuo guides",
+                        "What does AP mean?",
+                        "I keep losing as Jinx, help me",
+                        "What are good team compositions?",
+                        "How do I counter Yasuo?",
+                        "Show me educational videos about wave management"
+                    ],
+                    inputs=msg,
+                    label="Click to try:"
+                )
+                
+                gr.Markdown(
+                    """
+                    ### 🎯 Routing Intelligence
+                    
+                    The router automatically detects:
+                    - **Pre-game questions** → Pregame Agent
+                    - **Performance questions** → Match Analyzer
+                    - **Build questions** → Build Advisor
+                    - **Video requests** → Video Guide
+                    - **Learning questions** → Knowledge Base
+                    - **Complex questions** → Multi-agent orchestration
+                    """
+                )
+                
+                with gr.Accordion("📊 System Information", open=False):
+                    sys_info = coach.get_system_info()
+                    gr.JSON(value=sys_info, label="Active Agents")
+        
+        # Event handlers - Gradio 6.x format with role/content dictionaries
+        def respond(message, history):
+            """Handle chat response with proper Gradio 6.x format"""
+            if not message or not message.strip():
+                return history, ""
+            
+            bot_response = chat_wrapper(message, history)
+            
+            # Gradio 6.x expects list of dicts with 'role' and 'content'
+            history = history or []
+            history.append({"role": "user", "content": message})
+            history.append({"role": "assistant", "content": bot_response})
+            
+            return history, ""
+        
+        msg.submit(respond, [msg, chatbot], [chatbot, msg])
+        submit.click(respond, [msg, chatbot], [chatbot, msg])
+        clear.click(lambda: [], None, chatbot, queue=False)
+    
+    return demo
+
+
+# Example usage
+if __name__ == "__main__":
+    import sys
+    
+    # Create the multi-agent system
+    coach = create_multi_agent_coach()
+    
+    # Check if running with --ui flag
+    if "--ui" in sys.argv or "-ui" in sys.argv:
+        logger.info("Starting Gradio UI interface...")
+        print("\n🚀 Launching Gradio Web Interface...")
+        demo = create_gradio_interface(coach)
+        demo.launch(
+            share=True,
+            server_name="127.0.0.1",
+            server_port=7860
+        )
+    else:
+        # CLI test mode
+        # Test queries demonstrating different routing
+        test_queries = [
+            "Who should I ban in ranked?",  # → pregame_agent
+            "Analyze my recent matches",  # → match_analyzer
+            "What items should I build on Ahri?",  # → build_advisor
+            "Find Yasuo guides",  # → video_guide
+            "What does AP mean?",  # → knowledge_base
+            "I keep losing as Jinx, help me get better",  # → orchestrator (multiple agents)
+        ]
+        
+        print("\n" + "🧪" * 40)
+        print("TESTING MULTI-AGENT SYSTEM")
+        print("🧪" * 40 + "\n")
+        
+        for query in test_queries:
+            coach.chat(query)
+            print("\n")
+        
+        # Display system info
+        print("\n" + "ℹ️" * 40)
+        print("SYSTEM INFORMATION")
+        print("ℹ️" * 40)
+        import json
+        print(json.dumps(coach.get_system_info(), indent=2))
+        
+        print("\n💡 Tip: Run with '--ui' flag to launch web interface:")
+        print("   python multi_agent_coach.py --ui")
+

push.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# Quick push script for Hugging Face Space
+
+echo "🚀 Pushing LoL Multi-Agent Coach to Hugging Face..."
+echo ""
+
+cd /Users/ralitzamondal/Documents/LolMultiAgent
+
+# Check git status
+echo "📋 Current status:"
+git status
+echo ""
+
+# Ask user to confirm
+read -p "Ready to push? (y/n) " -n 1 -r
+echo ""
+
+if [[ $REPLY =~ ^[Yy]$ ]]
+then
+    echo "🔐 Pushing to Hugging Face..."
+    echo "   (You may need to enter your HF token)"
+    git push
+    
+    if [ $? -eq 0 ]; then
+        echo ""
+        echo "✅ SUCCESS! Your Space is updating!"
+        echo "🌐 Visit: https://huggingface.co/spaces/Ralitza1/LolMultiAgent"
+        echo ""
+        echo "⏳ Wait 5-10 minutes for build to complete"
+        echo "🔑 Don't forget to add API keys in Space Settings!"
+    else
+        echo ""
+        echo "❌ Push failed. You may need to:"
+        echo "   1. Get your HF token: https://huggingface.co/settings/tokens"
+        echo "   2. Run: huggingface-cli login"
+        echo "   3. Try again"
+    fi
+else
+    echo "❌ Push cancelled"
+fi

requirements.txt

@@ -0,0 +1,129 @@
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.2
+aiosignal==1.4.0
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.12.0
+attrs==25.4.0
+audioop-lts==0.2.2
+beautifulsoup4==4.14.3
+brotli==1.2.0
+cachetools==6.2.4
+certifi==2025.11.12
+charset-normalizer==3.4.4
+click==8.3.1
+dataclasses-json==0.6.7
+distro==1.9.0
+faiss-cpu==1.13.1
+fastapi==0.127.0
+ffmpy==1.0.0
+filelock==3.20.1
+frozenlist==1.8.0
+fsspec==2025.12.0
+google-api-core==2.28.1
+google-api-python-client==2.187.0
+google-auth==2.41.1
+google-auth-httplib2==0.3.0
+google-auth-oauthlib==1.2.3
+googleapis-common-protos==1.72.0
+gradio==6.2.0
+gradio_client==2.0.2
+groovy==0.1.2
+h11==0.16.0
+hf-xet==1.2.0
+httpcore==1.0.9
+httplib2==0.31.0
+httpx==0.28.1
+httpx-sse==0.4.3
+huggingface_hub==1.2.3
+idna==3.11
+iniconfig==2.3.0
+Jinja2==3.1.6
+jiter==0.12.0
+jsonpatch==1.33
+jsonpointer==3.0.0
+langchain==1.2.0
+langchain-classic==1.0.0
+langchain-community==0.4.1
+langchain-core==1.2.4
+langchain-openai==1.1.6
+langchain-text-splitters==1.1.0
+langgraph==1.0.5
+langgraph-checkpoint==3.0.1
+langgraph-prebuilt==1.0.5
+langgraph-sdk==0.3.1
+langsmith==0.5.0
+lxml==6.0.2
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+marshmallow==3.26.1
+mdurl==0.1.2
+multidict==6.7.0
+mypy_extensions==1.1.0
+numpy==2.4.0
+oauthlib==3.3.1
+openai==2.14.0
+orjson==3.11.5
+ormsgpack==1.12.1
+outcome==1.3.0.post0
+packaging==25.0
+pandas==2.3.3
+pillow==12.0.0
+pluggy==1.6.0
+propcache==0.4.1
+proto-plus==1.27.0
+protobuf==6.33.2
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pydantic==2.12.5
+pydantic-settings==2.12.0
+pydantic_core==2.41.5
+pydub==0.25.1
+Pygments==2.19.2
+pyparsing==3.2.5
+PySocks==1.7.1
+pytest==9.0.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.1
+python-multipart==0.0.21
+pytz==2025.2
+PyYAML==6.0.3
+regex==2025.11.3
+requests==2.32.5
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==14.2.0
+rsa==4.9.1
+safehttpx==0.1.7
+selenium==4.39.0
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+sortedcontainers==2.4.0
+soupsieve==2.8.1
+SQLAlchemy==2.0.45
+starlette==0.50.0
+tavily-python==0.7.19
+tenacity==9.1.2
+tiktoken==0.12.0
+tomlkit==0.13.3
+tqdm==4.67.1
+trio==0.32.0
+trio-websocket==0.12.2
+typer==0.20.1
+typer-slim==0.20.1
+typing-inspect==0.9.0
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2025.3
+uritemplate==4.2.0
+urllib3==2.6.2
+uuid_utils==0.12.0
+uvicorn==0.40.0
+websocket-client==1.9.0
+wsproto==1.3.2
+xxhash==3.6.0
+yarl==1.22.0
+zstandard==0.25.0

riot_api.py

@@ -0,0 +1,296 @@
+"""
+Riot Games API Integration
+
+Handles all interactions with the Riot Games API for fetching summoner data,
+match history, and game statistics.
+"""
+
+import requests
+import time
+from typing import Dict, List, Optional
+
+
+class RiotAPI:
+    """Wrapper for Riot Games API calls"""
+    
+    def __init__(self, api_key: str, region: str = "na1", routing: str = "americas"):
+        """
+        Initialize Riot API client
+        
+        Args:
+            api_key: Riot Games API key from developer.riotgames.com
+            region: Platform routing (na1, euw1, kr, etc.)
+            routing: Regional routing (americas, europe, asia, sea)
+        """
+        self.api_key = api_key
+        self.region = region
+        self.routing = routing
+        self.base_url = f"https://{region}.api.riotgames.com"
+        self.routing_url = f"https://{routing}.api.riotgames.com"
+        self.headers = {"X-Riot-Token": api_key}
+        
+        # Rate limiting
+        self.last_request_time = 0
+        self.min_request_interval = 0.05  # 50ms between requests
+    
+    def _rate_limit(self):
+        """Implement basic rate limiting"""
+        current_time = time.time()
+        time_since_last = current_time - self.last_request_time
+        if time_since_last < self.min_request_interval:
+            time.sleep(self.min_request_interval - time_since_last)
+        self.last_request_time = time.time()
+    
+    def _make_request(self, url: str) -> Optional[Dict]:
+        """Make API request with error handling"""
+        self._rate_limit()
+        
+        try:
+            response = requests.get(url, headers=self.headers, timeout=10)
+            
+            if response.status_code == 200:
+                return response.json()
+            elif response.status_code == 404:
+                print(f"❌ Not found: {url}")
+                return None
+            elif response.status_code == 429:
+                print("⚠️  Rate limit exceeded. Waiting...")
+                time.sleep(2)
+                return self._make_request(url)
+            elif response.status_code == 403:
+                print("❌ Invalid API key or expired")
+                return None
+            else:
+                print(f"❌ API Error {response.status_code}: {response.text}")
+                return None
+        except requests.exceptions.RequestException as e:
+            print(f"❌ Request failed: {str(e)}")
+            return None
+    
+    def get_account_by_riot_id(self, game_name: str, tag_line: str) -> Optional[Dict]:
+        """
+        Get account information by Riot ID (game name + tag line)
+        This is the new Riot ID system that replaced summoner names
+        
+        Args:
+            game_name: The game name (e.g., "BeLikeThatOrElse")
+            tag_line: The tag line (e.g., "NA1")
+        
+        Returns:
+            Dict with keys: puuid, gameName, tagLine
+        """
+        url = f"{self.routing_url}/riot/account/v1/accounts/by-riot-id/{game_name}/{tag_line}"
+        return self._make_request(url)
+    
+    def get_summoner_by_puuid(self, puuid: str) -> Optional[Dict]:
+        """
+        Get summoner information by PUUID
+        
+        Returns:
+            Dict with keys: id, accountId, puuid, name, summonerLevel, etc.
+        """
+        url = f"{self.base_url}/lol/summoner/v4/summoners/by-puuid/{puuid}"
+        return self._make_request(url)
+    
+    def get_summoner_by_name(self, summoner_name: str) -> Optional[Dict]:
+        """
+        Get summoner information by summoner name (DEPRECATED - use Riot ID instead)
+        
+        Returns:
+            Dict with keys: id, accountId, puuid, name, summonerLevel, etc.
+        """
+        url = f"{self.base_url}/lol/summoner/v4/summoners/by-name/{summoner_name}"
+        return self._make_request(url)
+    
+    def get_ranked_stats(self, summoner_id: str) -> Optional[List[Dict]]:
+        """
+        Get ranked statistics for a summoner
+        
+        Returns:
+            List of ranked queue info (Solo/Duo, Flex, etc.)
+        """
+        url = f"{self.base_url}/lol/league/v4/entries/by-summoner/{summoner_id}"
+        return self._make_request(url)
+    
+    def get_match_history(self, puuid: str, count: int = 20, queue: int = None) -> Optional[List[str]]:
+        """
+        Get match history IDs for a summoner
+        
+        Args:
+            puuid: Player UUID
+            count: Number of matches to retrieve (max 100)
+            queue: Queue ID filter (420=Ranked Solo, 400=Normal Draft, etc.)
+        
+        Returns:
+            List of match IDs
+        """
+        url = f"{self.routing_url}/lol/match/v5/matches/by-puuid/{puuid}/ids?count={count}"
+        if queue:
+            url += f"&queue={queue}"
+        return self._make_request(url)
+    
+    def get_match_details(self, match_id: str, puuid: str = None) -> Optional[Dict]:
+        """
+        Get detailed information about a match
+        
+        Args:
+            match_id: Match ID
+            puuid: If provided, returns only this player's stats
+        
+        Returns:
+            Match details or player-specific stats if puuid provided
+        """
+        url = f"{self.routing_url}/lol/match/v5/matches/{match_id}"
+        match_data = self._make_request(url)
+        
+        if not match_data:
+            return None
+        
+        # If puuid specified, extract only that player's data
+        if puuid:
+            participants = match_data.get('info', {}).get('participants', [])
+            for participant in participants:
+                if participant.get('puuid') == puuid:
+                    return self._format_player_stats(participant)
+            return None
+        
+        return match_data
+    
+    def get_match_with_enemies(self, match_id: str, puuid: str) -> Optional[Dict]:
+        """
+        Get match details including enemy team information
+        
+        Args:
+            match_id: Match ID
+            puuid: Player's UUID to identify their team
+        
+        Returns:
+            Dict with player stats and enemy team data
+        """
+        url = f"{self.routing_url}/lol/match/v5/matches/{match_id}"
+        match_data = self._make_request(url)
+        
+        if not match_data:
+            return None
+        
+        participants = match_data.get('info', {}).get('participants', [])
+        
+        # Find player and their team
+        player_data = None
+        player_team = None
+        
+        for participant in participants:
+            if participant.get('puuid') == puuid:
+                player_data = self._format_player_stats(participant)
+                player_team = participant.get('teamId')
+                break
+        
+        if not player_data:
+            return None
+        
+        # Get enemy team
+        enemies = []
+        for participant in participants:
+            if participant.get('teamId') != player_team:
+                enemies.append({
+                    'champion': participant.get('championName', 'Unknown'),
+                    'role': participant.get('teamPosition', 'Unknown'),
+                    'kills': participant.get('kills', 0),
+                    'deaths': participant.get('deaths', 0),
+                    'assists': participant.get('assists', 0),
+                })
+        
+        return {
+            'player': player_data,
+            'enemies': enemies,
+            'game_duration': match_data.get('info', {}).get('gameDuration', 0),
+        }
+    
+    def _format_player_stats(self, participant: Dict) -> Dict:
+        """Format participant data into clean stats"""
+        return {
+            'champion': participant.get('championName', 'Unknown'),
+            'kills': participant.get('kills', 0),
+            'deaths': participant.get('deaths', 0),
+            'assists': participant.get('assists', 0),
+            'cs': participant.get('totalMinionsKilled', 0) + participant.get('neutralMinionsKilled', 0),
+            'damage': participant.get('totalDamageDealtToChampions', 0),
+            'gold': participant.get('goldEarned', 0),
+            'vision_score': participant.get('visionScore', 0),
+            'win': participant.get('win', False),
+            'items': [
+                self._get_item_name(participant.get(f'item{i}', 0))
+                for i in range(7)
+            ],
+            'summoner_spells': [
+                participant.get('summoner1Id'),
+                participant.get('summoner2Id')
+            ],
+            'role': participant.get('teamPosition', 'Unknown'),
+            'game_duration': participant.get('gameDuration', 0),
+        }
+    
+    def _get_item_name(self, item_id: int) -> str:
+        """Convert item ID to name (simplified, would need Data Dragon for full names)"""
+        if item_id == 0:
+            return "Empty"
+        return f"Item {item_id}"
+    
+    def get_champion_mastery(self, puuid: str, champion_id: int = None) -> Optional[Dict]:
+        """
+        Get champion mastery information
+        
+        Args:
+            puuid: Player UUID
+            champion_id: Specific champion ID, or None for all
+        
+        Returns:
+            Champion mastery data
+        """
+        if champion_id:
+            url = f"{self.base_url}/lol/champion-mastery/v4/champion-masteries/by-puuid/{puuid}/by-champion/{champion_id}"
+        else:
+            url = f"{self.base_url}/lol/champion-mastery/v4/champion-masteries/by-puuid/{puuid}"
+        return self._make_request(url)
+    
+    def get_current_game(self, summoner_id: str) -> Optional[Dict]:
+        """
+        Get information about a summoner's current active game
+        
+        Returns:
+            Current game info or None if not in game
+        """
+        url = f"{self.base_url}/lol/spectator/v4/active-games/by-summoner/{summoner_id}"
+        return self._make_request(url)
+
+
+# Utility functions
+
+def calculate_kda(kills: int, deaths: int, assists: int) -> float:
+    """Calculate KDA ratio"""
+    if deaths == 0:
+        return float(kills + assists)
+    return (kills + assists) / deaths
+
+
+def calculate_cs_per_min(cs: int, game_duration: int) -> float:
+    """Calculate CS per minute"""
+    if game_duration == 0:
+        return 0.0
+    minutes = game_duration / 60
+    return cs / minutes
+
+
+def get_rank_tier(tier: str, division: str) -> int:
+    """Convert rank to numeric tier for comparison"""
+    tier_values = {
+        'IRON': 0, 'BRONZE': 1, 'SILVER': 2, 'GOLD': 3,
+        'PLATINUM': 4, 'EMERALD': 5, 'DIAMOND': 6,
+        'MASTER': 7, 'GRANDMASTER': 8, 'CHALLENGER': 9
+    }
+    division_values = {'IV': 0, 'III': 1, 'II': 2, 'I': 3}
+    
+    tier_value = tier_values.get(tier.upper(), 0) * 4
+    div_value = division_values.get(division, 0)
+    
+    return tier_value + div_value

specialized_agents.py

@@ -0,0 +1,359 @@
+"""
+Specialized Agents for LoL Coach Multi-Agent System
+Each agent is an expert in a specific domain with specialized tools.
+"""
+
+import logging
+from typing import List, Dict, Any
+from langchain_openai import ChatOpenAI
+from langchain.tools import tool
+from langgraph.prebuilt import create_react_agent
+from langgraph.checkpoint.memory import MemorySaver
+from langchain_core.messages import SystemMessage
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+
+class BaseLoLAgent:
+    """Base class for all specialized LoL coaching agents."""
+    
+    def __init__(self, llm: ChatOpenAI, tools: List, system_prompt: str, name: str):
+        self.name = name
+        self.llm = llm
+        self.tools = tools
+        self.system_prompt = system_prompt
+        self.memory = MemorySaver()
+        logger.info(f"Initializing {name} agent with {len(tools)} tools")
+        self.agent = create_react_agent(
+            llm,
+            tools,
+            checkpointer=self.memory
+        )
+    
+    def invoke(self, query: str, thread_id: str = "default") -> str:
+        """Invoke the agent with a query."""
+        logger.debug(f"{self.name} invoked with query: {query[:100]}...")
+        config = {"configurable": {"thread_id": thread_id}}
+        
+        try:
+            # Add system prompt as first message
+            messages = [
+                SystemMessage(content=self.system_prompt),
+                ("user", query)
+            ]
+            
+            response = self.agent.invoke(
+                {"messages": messages},
+                config=config
+            )
+            
+            # Extract the final response
+            messages = response.get("messages", [])
+            if messages:
+                result = messages[-1].content
+                logger.debug(f"{self.name} generated response of length {len(result)}")
+                return result
+            
+            logger.warning(f"{self.name} generated no response")
+            return "No response generated."
+            
+        except Exception as e:
+            logger.error(f"{self.name} invoke failed: {str(e)}", exc_info=True)
+            return f"Error: {str(e)}"
+    
+    def get_info(self) -> Dict[str, Any]:
+        """Get agent information."""
+        return {
+            "name": self.name,
+            "tool_count": len(self.tools),
+            "tools": [tool.name for tool in self.tools]
+        }
+
+
+class MatchAnalyzerAgent(BaseLoLAgent):
+    """
+    🎯 Specialized agent for analyzing match history and performance.
+    
+    Expertise:
+    - Match history analysis
+    - Performance statistics
+    - Win/loss tracking
+    - Enemy champion analysis
+    - Build comparisons from past games
+    """
+    
+    def __init__(self, llm: ChatOpenAI, match_tools: List):
+        system_prompt = """You are the Match Analyzer Agent, an expert at analyzing League of Legends match history and player performance.
+
+Your expertise:
+- Analyzing recent match data and trends
+- Identifying performance patterns
+- Comparing player stats across games
+- Analyzing matchups against specific enemy champions
+- Reviewing build choices from past games
+
+Your communication style:
+- Data-driven and analytical
+- Highlight trends and patterns
+- Provide specific statistics
+- Compare performance across games
+- Offer actionable insights based on data
+
+When analyzing matches:
+1. Look for trends across multiple games
+2. Identify what's working and what isn't
+3. Compare against enemy champions
+4. Note build effectiveness
+5. Provide clear, specific recommendations
+
+Always base your analysis on actual match data and statistics."""
+
+        super().__init__(llm, match_tools, system_prompt, "Match Analyzer")
+
+
+class BuildAdvisorAgent(BaseLoLAgent):
+    """
+    🛠️ Specialized agent for build recommendations and champion advice.
+    
+    Expertise:
+    - Optimal item builds
+    - Rune recommendations
+    - Champion matchups
+    - Counter picks
+    - Build optimization strategies
+    """
+    
+    def __init__(self, llm: ChatOpenAI, build_tools: List):
+        system_prompt = """You are the Build Advisor Agent, an expert at recommending optimal builds, runes, and champions for League of Legends.
+
+Your expertise:
+- Optimal item builds for any champion and role
+- Best rune pages and setups
+- Champion matchup advice
+- Counter picks and strategies
+- Build adaptations for different situations
+
+Your communication style:
+- Clear and instructional
+- Explain WHY builds work
+- Provide situational alternatives
+- Consider enemy team composition
+- Offer practical, tested recommendations
+
+When recommending builds:
+1. Consider the champion's playstyle
+2. Factor in enemy team composition
+3. Explain item synergies
+4. Suggest rune reasoning
+5. Provide build order and power spikes
+
+Always use current meta builds from U.GG and explain your recommendations."""
+
+        super().__init__(llm, build_tools, system_prompt, "Build Advisor")
+
+
+class VideoGuideAgent(BaseLoLAgent):
+    """
+    🎬 Specialized agent for finding YouTube guides and educational content.
+    
+    Expertise:
+    - YouTube video searches
+    - Champion guide recommendations
+    - Matchup-specific videos
+    - Educational tutorials
+    - Pro gameplay examples
+    """
+    
+    def __init__(self, llm: ChatOpenAI, video_tools: List):
+        system_prompt = """You are the Video Guide Agent, an expert at finding the best YouTube videos and educational content for League of Legends players.
+
+Your expertise:
+- Finding high-quality champion guides
+- Locating matchup-specific gameplay videos
+- Discovering educational content on game concepts
+- Recommending relevant tutorials
+- Curating learning resources
+
+Your communication style:
+- Enthusiastic and encouraging
+- Explain what to watch for in videos
+- Highlight key learning points
+- Suggest viewing order for multiple videos
+- Make learning feel approachable
+
+When recommending videos:
+1. Search for relevant, recent content
+2. Explain what players will learn
+3. Highlight key takeaways
+4. Suggest what to focus on while watching
+5. Connect videos to player's goals
+
+Always provide video context and learning objectives."""
+
+        super().__init__(llm, video_tools, system_prompt, "Video Guide")
+
+
+class KnowledgeAgent(BaseLoLAgent):
+    """
+    📚 Specialized agent for explaining game concepts and terminology.
+    
+    Expertise:
+    - Game mechanics explanations
+    - Terminology definitions
+    - Concept clarifications
+    - Strategy fundamentals
+    - General LoL knowledge
+    """
+    
+    def __init__(self, llm: ChatOpenAI, knowledge_tools: List):
+        system_prompt = """You are the Knowledge Agent, an expert at explaining League of Legends concepts, terminology, and game mechanics.
+
+Your expertise:
+- Clear explanations of game terms (AP, AD, armor, etc.)
+- Game mechanics and how they work
+- Strategic concepts (wave management, vision control, etc.)
+- Champion abilities and interactions
+- General League of Legends knowledge
+
+Your communication style:
+- Patient and educational
+- Use simple language first, then add depth
+- Provide examples to illustrate concepts
+- Connect concepts to practical gameplay
+- Encourage learning and understanding
+
+When explaining concepts:
+1. Start with a clear, simple definition
+2. Explain how it works in practice
+3. Provide concrete examples
+4. Connect to gameplay situations
+5. Suggest how to apply the knowledge
+
+Always make complex concepts accessible and understandable."""
+
+        super().__init__(llm, knowledge_tools, system_prompt, "Knowledge Base")
+
+
+class PregameAgent(BaseLoLAgent):
+    """
+    🎯 Specialized agent for champion select and draft strategy.
+    
+    Expertise:
+    - Champion select recommendations
+    - Ban strategy and meta analysis
+    - Team composition synergy
+    - Counter-picking advice
+    - Draft phase optimization
+    - Role assignment strategy
+    """
+    
+    def __init__(self, llm: ChatOpenAI, pregame_tools: List):
+        system_prompt = """You are the Pregame Agent, an expert at champion select, drafting, and pre-game strategy.
+
+Your expertise:
+- Optimal ban recommendations based on current meta and counters
+- Champion select strategy for each role
+- Team composition analysis and champion synergy
+- Counter-picking strategies against enemy champions
+- Draft phase optimization and priority picking
+- Role assignment and lane matchup evaluation
+- Champion pool recommendations for climbing ranked
+
+Your communication style:
+- Strategic and tactical
+- Consider both teams' compositions
+- Explain pick/ban reasoning clearly
+- Adapt advice to player's champion pool
+- Focus on win conditions and team synergy
+- Provide backup options and flexibility
+
+When providing draft advice:
+1. Analyze enemy team composition if available
+2. Consider team synergy and win conditions
+3. Recommend champions based on role and matchup
+4. Explain counter-pick opportunities
+5. Suggest ban priorities (high-priority meta picks, hard counters)
+6. Provide multiple options with reasoning
+7. Consider player comfort vs optimal picks
+
+For bans specifically:
+- Prioritize overpowered meta champions
+- Ban hard counters to your team's picks
+- Consider enemy team's likely picks
+- Ban champions that enable problematic team compositions
+
+For champion select:
+- Match champion to player's role and skill level
+- Consider lane matchup and counter-picks
+- Evaluate team synergy (engage, poke, scaling, etc.)
+- Suggest champions that fit the team's win condition
+- Provide safe blind picks vs strong counter-picks
+
+Always prioritize strategic depth while being practical about player skill and champion pool."""
+
+        super().__init__(llm, pregame_tools, system_prompt, "Pregame Strategy")
+
+
+def create_specialized_agents(
+    llm: ChatOpenAI,
+    all_tools: Dict[str, List]
+) -> Dict[str, BaseLoLAgent]:
+    """
+    Create all specialized agents with their respective tools.
+    
+    Args:
+        llm: ChatOpenAI instance
+        all_tools: Dictionary mapping tool categories to tool lists
+            - "match": Match analysis tools
+            - "build": Build/champion advice tools  
+            - "video": YouTube search tools
+            - "knowledge": Knowledge base tools
+            - "pregame": Pregame/draft strategy tools
+    
+    Returns:
+        Dictionary mapping agent names to agent instances
+    """
+    agents = {
+        "match_analyzer": MatchAnalyzerAgent(
+            llm=llm,
+            match_tools=all_tools.get("match", [])
+        ),
+        "build_advisor": BuildAdvisorAgent(
+            llm=llm,
+            build_tools=all_tools.get("build", [])
+        ),
+        "video_guide": VideoGuideAgent(
+            llm=llm,
+            video_tools=all_tools.get("video", [])
+        ),
+        "knowledge_base": KnowledgeAgent(
+            llm=llm,
+            knowledge_tools=all_tools.get("knowledge", [])
+        ),
+        "pregame_agent": PregameAgent(
+            llm=llm,
+            pregame_tools=all_tools.get("pregame", [])
+        )
+    }
+    
+    return agents
+
+
+# Example agent info display
+if __name__ == "__main__":
+    print("=" * 80)
+    print("🤖 LoL Coach - Specialized Agents")
+    print("=" * 80)
+    
+    agent_descriptions = {
+        "Match Analyzer": "🎯 Analyzes match history, performance stats, and game trends",
+        "Build Advisor": "🛠️ Recommends optimal items, runes, and champion strategies",
+        "Video Guide": "🎬 Finds YouTube guides, tutorials, and educational content",
+        "Knowledge Base": "📚 Explains game concepts, terminology, and mechanics",
+        "Pregame Strategy": "🎯 Champion select, draft strategy, and ban recommendations"
+    }
+    
+    for name, desc in agent_descriptions.items():
+        print(f"\n{desc}")
+        print(f"   Agent: {name}")

youtube_scraper.py

@@ -0,0 +1,317 @@
+"""
+YouTube Web Scraper
+Alternative to YouTube Data API - scrapes video data directly from YouTube pages
+Useful as backup when API quota is exceeded or for additional metadata
+"""
+
+import requests
+from bs4 import BeautifulSoup
+from typing import List, Dict, Optional
+import re
+import json
+from urllib.parse import quote_plus, urljoin
+
+
+class YouTubeScraper:
+    """Scrape YouTube video data without using API quota"""
+    
+    BASE_URL = "https://www.youtube.com"
+    SEARCH_URL = f"{BASE_URL}/results"
+    
+    def __init__(self):
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'DNT': '1',
+            'Connection': 'keep-alive',
+            'Upgrade-Insecure-Requests': '1'
+        })
+    
+    def search_videos(self, query: str, max_results: int = 5) -> List[Dict]:
+        """
+        Search YouTube and scrape video results
+        
+        Args:
+            query: Search query
+            max_results: Maximum number of results to return
+        
+        Returns:
+            List of video dictionaries
+        """
+        try:
+            # Construct search URL
+            encoded_query = quote_plus(query)
+            url = f"{self.SEARCH_URL}?search_query={encoded_query}"
+            
+            print(f"🔍 Scraping YouTube search: {query}")
+            
+            response = self.session.get(url, timeout=15)
+            response.raise_for_status()
+            
+            # Parse HTML
+            soup = BeautifulSoup(response.content, 'html.parser')
+            
+            # YouTube embeds data in JavaScript - extract it
+            videos = self._extract_video_data(soup, max_results)
+            
+            if not videos:
+                print("⚠️  No videos found via scraping, trying alternative method")
+                videos = self._extract_from_scripts(response.text, max_results)
+            
+            print(f"✅ Scraped {len(videos)} videos from YouTube")
+            return videos[:max_results]
+            
+        except Exception as e:
+            print(f"❌ YouTube scraping error: {e}")
+            return []
+    
+    def _extract_video_data(self, soup: BeautifulSoup, max_results: int) -> List[Dict]:
+        """Extract video data from HTML elements"""
+        videos = []
+        
+        try:
+            # YouTube uses various class names - try multiple patterns
+            video_selectors = [
+                'ytd-video-renderer',
+                'ytd-playlist-video-renderer',
+                'ytd-grid-video-renderer'
+            ]
+            
+            for selector in video_selectors:
+                video_elements = soup.find_all(selector)
+                
+                for element in video_elements[:max_results]:
+                    if len(videos) >= max_results:
+                        break
+                    
+                    try:
+                        video_data = self._parse_video_element(element)
+                        if video_data:
+                            videos.append(video_data)
+                    except Exception as e:
+                        print(f"⚠️  Error parsing video element: {e}")
+                        continue
+                
+                if videos:
+                    break  # Found videos, no need to try other selectors
+            
+            return videos
+            
+        except Exception as e:
+            print(f"⚠️  HTML extraction error: {e}")
+            return []
+    
+    def _parse_video_element(self, element) -> Optional[Dict]:
+        """Parse individual video element"""
+        try:
+            # Extract video ID
+            video_link = element.find('a', id='video-title')
+            if not video_link:
+                return None
+            
+            video_id = None
+            href = video_link.get('href', '')
+            if '/watch?v=' in href:
+                video_id = href.split('/watch?v=')[1].split('&')[0]
+            
+            if not video_id:
+                return None
+            
+            # Extract title
+            title = video_link.get('title', '') or video_link.get_text(strip=True)
+            
+            # Extract channel name
+            channel_elem = element.find('ytd-channel-name') or element.find('a', class_='yt-simple-endpoint')
+            channel = channel_elem.get_text(strip=True) if channel_elem else 'Unknown'
+            
+            # Extract view count and duration
+            metadata = element.find_all('span', class_='style-scope ytd-video-meta-block')
+            views_text = 'N/A'
+            duration = 'N/A'
+            
+            for meta in metadata:
+                text = meta.get_text(strip=True)
+                if 'view' in text.lower():
+                    views_text = text
+                elif ':' in text:
+                    duration = text
+            
+            # Extract thumbnail
+            thumbnail_elem = element.find('img')
+            thumbnail = thumbnail_elem.get('src', '') if thumbnail_elem else ''
+            
+            # Parse view count
+            views = self._parse_view_count(views_text)
+            
+            return {
+                'video_id': video_id,
+                'title': title,
+                'url': f"https://www.youtube.com/watch?v={video_id}",
+                'channel': channel,
+                'views': views,
+                'views_text': views_text,
+                'duration': duration,
+                'thumbnail': thumbnail,
+                'description': title[:200] + '...',  # Use title as description
+            }
+            
+        except Exception as e:
+            print(f"⚠️  Parse element error: {e}")
+            return None
+    
+    def _extract_from_scripts(self, html_text: str, max_results: int) -> List[Dict]:
+        """Extract video data from embedded JavaScript"""
+        videos = []
+        
+        try:
+            # YouTube embeds data in ytInitialData variable
+            pattern = r'var ytInitialData = ({.*?});'
+            match = re.search(pattern, html_text, re.DOTALL)
+            
+            if match:
+                try:
+                    data = json.loads(match.group(1))
+                    
+                    # Navigate YouTube's data structure
+                    contents = (data.get('contents', {})
+                               .get('twoColumnSearchResultsRenderer', {})
+                               .get('primaryContents', {})
+                               .get('sectionListRenderer', {})
+                               .get('contents', []))
+                    
+                    for section in contents:
+                        item_section = section.get('itemSectionRenderer', {})
+                        video_items = item_section.get('contents', [])
+                        
+                        for item in video_items[:max_results]:
+                            if len(videos) >= max_results:
+                                break
+                            
+                            video_renderer = item.get('videoRenderer')
+                            if video_renderer:
+                                video_data = self._parse_video_renderer(video_renderer)
+                                if video_data:
+                                    videos.append(video_data)
+                
+                except json.JSONDecodeError as e:
+                    print(f"⚠️  JSON decode error: {e}")
+            
+            return videos
+            
+        except Exception as e:
+            print(f"⚠️  Script extraction error: {e}")
+            return []
+    
+    def _parse_video_renderer(self, renderer: Dict) -> Optional[Dict]:
+        """Parse video data from ytInitialData structure"""
+        try:
+            video_id = renderer.get('videoId')
+            if not video_id:
+                return None
+            
+            # Extract title
+            title_runs = renderer.get('title', {}).get('runs', [])
+            title = title_runs[0].get('text', 'Unknown') if title_runs else 'Unknown'
+            
+            # Extract channel
+            owner_text = renderer.get('ownerText', {}).get('runs', [])
+            channel = owner_text[0].get('text', 'Unknown') if owner_text else 'Unknown'
+            
+            # Extract view count
+            view_count_text = renderer.get('viewCountText', {}).get('simpleText', '0 views')
+            views = self._parse_view_count(view_count_text)
+            
+            # Extract duration
+            length_text = renderer.get('lengthText', {}).get('simpleText', 'N/A')
+            
+            # Extract thumbnail
+            thumbnails = renderer.get('thumbnail', {}).get('thumbnails', [])
+            thumbnail = thumbnails[-1].get('url', '') if thumbnails else ''
+            
+            return {
+                'video_id': video_id,
+                'title': title,
+                'url': f"https://www.youtube.com/watch?v={video_id}",
+                'channel': channel,
+                'views': views,
+                'views_text': view_count_text,
+                'duration': length_text,
+                'thumbnail': thumbnail,
+                'description': title[:200] + '...',
+            }
+            
+        except Exception as e:
+            print(f"⚠️  Renderer parse error: {e}")
+            return None
+    
+    def _parse_view_count(self, view_text: str) -> int:
+        """Parse view count from text like '1.2M views' or '50K views'"""
+        try:
+            # Remove 'views' and extra spaces
+            view_text = view_text.lower().replace('views', '').replace('view', '').strip()
+            
+            # Handle K, M, B suffixes
+            multipliers = {
+                'k': 1_000,
+                'm': 1_000_000,
+                'b': 1_000_000_000
+            }
+            
+            for suffix, multiplier in multipliers.items():
+                if suffix in view_text:
+                    number = float(view_text.replace(suffix, '').strip())
+                    return int(number * multiplier)
+            
+            # Try to parse as plain number
+            view_text = re.sub(r'[^\d.]', '', view_text)
+            return int(float(view_text)) if view_text else 0
+            
+        except Exception:
+            return 0
+    
+    def format_video_list(self, videos: List[Dict]) -> str:
+        """Format video list for display"""
+        if not videos:
+            return "No videos found."
+        
+        result = ""
+        for i, video in enumerate(videos, 1):
+            views_k = video['views'] / 1000 if video['views'] > 0 else 0
+            result += f"{i}. **{video['title']}**\n"
+            result += f"   • Channel: {video['channel']}\n"
+            result += f"   • Duration: {video['duration']} | Views: {views_k:.1f}K\n"
+            result += f"   • Link: {video['url']}\n\n"
+        
+        return result
+
+
+# Test the scraper
+if __name__ == "__main__":
+    print("🎬 Testing YouTube Scraper\n")
+    
+    scraper = YouTubeScraper()
+    
+    # Test searches
+    test_queries = [
+        "League of Legends Ahri guide 2024",
+        "Ahri vs Zed gameplay",
+        "League wave management tutorial"
+    ]
+    
+    for query in test_queries:
+        print(f"\n{'='*60}")
+        print(f"Testing: {query}")
+        print('='*60)
+        
+        videos = scraper.search_videos(query, max_results=3)
+        
+        if videos:
+            print(f"✅ Found {len(videos)} videos:\n")
+            print(scraper.format_video_list(videos))
+        else:
+            print("❌ No videos found")
+        
+        print()