Update app.py

app.py

@@ -87,7 +87,95 @@ def initialize_rag_components():
         print("✅ Text splitter initialized.")
     
     return True
+# =============================================================================
+# ANSWER SHEET VALIDATION FUNCTIONS
+# =============================================================================
+
+def load_answer_sheet(filepath: str = "answer_sheet.json") -> Dict[str, str]:
+    """Load the answer sheet from a JSON file"""
+    try:
+        if os.path.exists(filepath):
+            with open(filepath, 'r', encoding='utf-8') as f:
+                answers = json.load(f)
+            print(f"✅ Loaded answer sheet with {len(answers)} answers from {filepath}")
+            return answers
+        else:
+            print(f"⚠️ Answer sheet not found at {filepath}")
+            return {}
+    except Exception as e:
+        print(f"❌ Error loading answer sheet: {e}")
+        return {}
+
+
+def check_answer_correctness(submitted: str, correct: str) -> Tuple[bool, str]:
+    """
+    Check if submitted answer matches correct answer with fuzzy matching
+    Returns: (is_correct, feedback_message)
+    """
+    # Normalize both answers
+    submitted_norm = submitted.strip().lower()
+    correct_norm = correct.strip().lower()
+    
+    # Exact match
+    if submitted_norm == correct_norm:
+        return True, "✅ EXACT MATCH"
+    
+    # Remove common punctuation and check again
+    import string
+    submitted_clean = submitted_norm.translate(str.maketrans('', '', string.punctuation))
+    correct_clean = correct_norm.translate(str.maketrans('', '', string.punctuation))
+    
+    if submitted_clean == correct_clean:
+        return True, "✅ MATCH (punctuation difference)"
+    
+    # Check if it's a number formatting issue
+    try:
+        # Try to parse as numbers
+        submitted_num = float(submitted_clean.replace(',', '').replace('$', ''))
+        correct_num = float(correct_clean.replace(',', '').replace('$', ''))
+        if abs(submitted_num - correct_num) < 0.01:  # Allow small floating point differences
+            return True, "✅ MATCH (numeric equivalence)"
+    except (ValueError, AttributeError):
+        pass
+    
+    # Check if submitted answer contains correct answer (for list-type answers)
+    if ',' in correct_norm:
+        correct_items = set([item.strip() for item in correct_norm.split(',')])
+        submitted_items = set([item.strip() for item in submitted_norm.split(',')])
+        
+        if correct_items == submitted_items:
+            return True, "✅ MATCH (item order difference)"
+        
+        missing_items = correct_items - submitted_items
+        extra_items = submitted_items - correct_items
+        
+        if missing_items and not extra_items:
+            return False, f"❌ MISSING: {', '.join(missing_items)}"
+        elif extra_items and not missing_items:
+            return False, f"❌ EXTRA: {', '.join(extra_items)}"
+        elif missing_items and extra_items:
+            return False, f"❌ MISSING: {', '.join(missing_items)} | EXTRA: {', '.join(extra_items)}"
+    
+    # Check case-insensitive substring match
+    if submitted_norm in correct_norm or correct_norm in submitted_norm:
+        return False, f"❌ PARTIAL MATCH (submitted: '{submitted}' | correct: '{correct}')"
+    
+    return False, f"❌ WRONG (submitted: '{submitted}' | correct: '{correct}')"
 
+
+def create_answer_sheet_template(questions: List[Dict], filepath: str = "answer_sheet.json"):
+    """Create an answer sheet template from questions"""
+    answer_template = {}
+    for q in questions:
+        answer_template[q['task_id']] = ""
+    
+    with open(filepath, 'w', encoding='utf-8') as f:
+        json.dump(answer_template, f, indent=2)
+    
+    print(f"✅ Created answer sheet template at {filepath}")
+    print(f"   Please fill in the correct answers for {len(answer_template)} questions")
+
+    
 # =============================================================================
 # ASR INITIALIZATION
 # =============================================================================
@@ -270,17 +358,41 @@ class SearchInput(BaseModel):
 
 @tool(args_schema=SearchInput)
 def search_tool(query: str) -> str:
-    """Searches web via DuckDuckGo. Use for facts, recent info."""
+    """
+    Search the web for information. Returns snippets.
+    
+    IMPORTANT: Search results are SNIPPETS only. For complete information:
+    1. Use search_tool to find URLs
+    2. Use scrape_and_retrieve to get FULL page content
+    
+    Example workflow:
+    - search_tool("Mercedes Sosa Wikipedia") → get URL
+    - scrape_and_retrieve(url=..., query="studio albums 2000-2009")
+    """
     if not isinstance(query, str) or not query.strip():
         return "Error: Invalid query."
     
+    # Auto-add Wikipedia site filter if mentioned
+    if 'wikipedia' in query.lower() and 'site:' not in query:
+        query = f"{query} site:wikipedia.org"
+    
     print(f"🔍 Searching: {query}")
-    try:
-        search = DuckDuckGoSearchRun()
-        result = search.run(query)
-        return truncate_if_needed(result)
-    except Exception as e:
-        return f"Search error: {str(e)}"
+    
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            search = DuckDuckGoSearchRun()
+            result = search.run(query)
+            
+            if not result or len(result) < 50:
+                return "No relevant results found. Try different search terms or check if the information exists."
+            
+            return truncate_if_needed(result)
+        except Exception as e:
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)
+                continue
+            return f"Search error after {max_retries} attempts: {str(e)}"
 
 
 class CalcInput(BaseModel):
@@ -318,8 +430,7 @@ class CodeInput(BaseModel):
 @tool(args_schema=CodeInput)
 def code_interpreter(code: str) -> str:
     """
-    Executes Python code. Use for data processing, complex logic.
-    Available: pandas, numpy, json, re, datetime
+    Executes Python code with timeout protection.
     CRITICAL: Always use print() to output results!
     """
     if not isinstance(code, str):
@@ -560,164 +671,413 @@ class YoutubeInput(BaseModel):
 
 @tool(args_schema=YoutubeInput)
 def get_youtube_transcript(video_url: str) -> str:
-    """Fetches YouTube video transcript using yt-dlp."""
+    """
+    Fetches YouTube video transcript with retry logic.
+    Returns N/A if video is inaccessible.
+    """
     if not video_url:
         return "Error: Invalid URL."
     
     print(f"📺 YouTube transcript: {video_url}")
     
-    try:
-        # Extract video ID
-        video_id = None
-        if "watch?v=" in video_url:
-            video_id = video_url.split("v=")[1].split("&")[0]
-        elif "youtu.be/" in video_url:
-            video_id = video_url.split("youtu.be/")[1].split("?")[0]
-        
-        if not video_id:
-            return f"Error: Could not extract video ID."
-        
-        # Use yt-dlp to get subtitles
-        subtitle_file = f'{video_id}.en.vtt'
-        
-        cmd = [
-            'yt-dlp',
-            '--skip-download',
-            '--write-auto-subs',
-            '--write-subs',
-            '--sub-lang', 'en',
-            '--sub-format', 'vtt',
-            '--output', video_id,
-            video_url
-        ]
-        
-        print(f"🔧 Running: {' '.join(cmd)}")
-        result = subprocess.run(cmd, capture_output=True, text=True, timeout=45)
-        
-        if result.returncode != 0:
-            print(f"⚠️ yt-dlp stderr: {result.stderr}")
-            return f"Error: Could not fetch subtitles - {result.stderr[:200]}"
-        
-        # Try to find the subtitle file (might have different naming)
-        import glob
-        vtt_files = glob.glob(f"{video_id}*.vtt")
-        
-        if not vtt_files:
-            return "Error: No English subtitles found for this video."
-        
-        subtitle_file = vtt_files[0]
-        print(f"✓ Found subtitle file: {subtitle_file}")
-        
-        # Read and parse VTT file
-        with open(subtitle_file, 'r', encoding='utf-8') as f:
-            content = f.read()
-        
-        # Remove VTT headers and timestamps
-        lines = content.split('\n')
-        transcript_parts = []
-        
-        for line in lines:
-            line = line.strip()
-            # Skip WEBVTT header, timestamps, and empty lines
-            if (line and 
-                not line.startswith('WEBVTT') and 
-                not '-->' in line and
-                not line.isdigit() and
-                not line.startswith('Kind:') and
-                not line.startswith('Language:')):
-                transcript_parts.append(line)
-        
-        full_transcript = " ".join(transcript_parts)
-        
-        # Cleanup subtitle files
-        for vtt_file in vtt_files:
-            try:
-                os.remove(vtt_file)
-            except:
-                pass
-        
-        if not full_transcript:
-            return "Error: Transcript was empty."
-        
-        print(f"✓ Transcript extracted: {len(full_transcript)} chars")
-        return f"Transcript:\n{truncate_if_needed(full_transcript)}"
-        
-    except subprocess.TimeoutExpired:
-        return "Error: yt-dlp timed out after 45 seconds."
-    except FileNotFoundError:
-        return "Error: yt-dlp not installed. Add 'yt-dlp' to requirements.txt"
-    except Exception as e:
-        print(f"❌ Error: {str(e)}")
-        print(traceback.format_exc())
-        return f"Transcript error: {str(e)}"
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            # Extract video ID
+            video_id = None
+            if "watch?v=" in video_url:
+                video_id = video_url.split("v=")[1].split("&")[0]
+            elif "youtu.be/" in video_url:
+                video_id = video_url.split("youtu.be/")[1].split("?")[0]
+            
+            if not video_id:
+                return f"Error: Could not extract video ID from URL."
+            
+            cmd = [
+                'yt-dlp',
+                '--skip-download',
+                '--write-auto-subs',
+                '--write-subs',
+                '--sub-lang', 'en',
+                '--sub-format', 'vtt',
+                '--output', video_id,
+                video_url
+            ]
+            
+            print(f"🔧 Running yt-dlp (attempt {attempt + 1}/{max_retries})...")
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=45)
+            
+            if result.returncode != 0:
+                stderr = result.stderr
+                
+                # Check for network errors
+                if 'Failed to resolve' in stderr or 'No address associated' in stderr:
+                    if attempt < max_retries - 1:
+                        print(f"⚠️ Network error, retrying...")
+                        time.sleep(2 ** attempt)
+                        continue
+                    return "N/A - YouTube is inaccessible due to network issues."
+                
+                return f"Error: Could not fetch subtitles - {stderr[:200]}"
+            
+            # Find subtitle file
+            import glob
+            vtt_files = glob.glob(f"{video_id}*.vtt")
+            
+            if not vtt_files:
+                return "N/A - No English subtitles found for this video."
+            
+            subtitle_file = vtt_files[0]
+            print(f"✓ Found subtitle file: {subtitle_file}")
+            
+            # Parse VTT
+            with open(subtitle_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            lines = content.split('\n')
+            transcript_parts = []
+            
+            for line in lines:
+                line = line.strip()
+                if (line and 
+                    not line.startswith('WEBVTT') and 
+                    not '-->' in line and
+                    not line.isdigit() and
+                    not line.startswith('Kind:') and
+                    not line.startswith('Language:')):
+                    transcript_parts.append(line)
+            
+            full_transcript = " ".join(transcript_parts)
+            
+            # Cleanup
+            for vtt_file in vtt_files:
+                try:
+                    os.remove(vtt_file)
+                except:
+                    pass
+            
+            if not full_transcript:
+                return "Error: Transcript was empty."
+            
+            print(f"✓ Transcript extracted: {len(full_transcript)} chars")
+            return f"Transcript:\n{truncate_if_needed(full_transcript)}"
+            
+        except subprocess.TimeoutExpired:
+            if attempt < max_retries - 1:
+                continue
+            return "N/A - YouTube request timed out."
+        except FileNotFoundError:
+            return "Error: yt-dlp not installed."
+        except Exception as e:
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)
+                continue
+            print(f"❌ Error: {str(e)}")
+            return f"Error: {str(e)}"
+    
+    return "N/A - YouTube transcript unavailable after multiple attempts."
 
 
 class ScrapeInput(BaseModel):
     url: str = Field(description="URL (must start with http:// or https://)")
-    query: str = Field(description="What to find on the page")
+    query: str = Field(description="Specific information to find on the page")
 
 @tool(args_schema=ScrapeInput)
 def scrape_and_retrieve(url: str, query: str) -> str:
     """
-    Scrapes webpage and uses RAG to find relevant info.
-    Use when you need specific info from a known URL.
+    Fetch and search FULL webpage content using RAG (not just snippets like search_tool).
+    
+    CRITICAL: Use this after search_tool gives you a URL. This gets the COMPLETE page.
+    
+    Workflow Example:
+    1. search_tool('Mercedes Sosa Wikipedia') → get URL
+    2. scrape_and_retrieve(
+         url='https://en.wikipedia.org/wiki/Mercedes_Sosa',
+         query='studio albums released between 2000 and 2009'
+       ) → Returns FULL discography section
+    
+    Use when:
+    - Counting items (albums, people, events, etc.)
+    - Finding specific names, dates, or numbers
+    - Need complete tables or lists
+    - Wikipedia articles, documentation, papers
+    - Search snippets weren't enough
     """
     if not url.startswith(('http://', 'https://')):
-        return f"Error: Invalid URL format."
+        return f"Error: Invalid URL format. Must start with http:// or https://"
     if not query:
-        return "Error: Query required."
+        return "Error: Query required to search the page content."
     
     if global_embeddings is None or global_text_splitter is None:
         if not initialize_rag_components():
-            return "Error: RAG not initialized."
+            return "Error: RAG components not initialized."
 
     print(f"🌐 Scraping: {url}")
+    print(f"   Looking for: {query[:100]}...")
     
+    max_retries = 3
+    for attempt in range(max_retries):
+        try:
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+            response = requests.get(url, headers=headers, timeout=20)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Remove noise
+            for tag in soup(["script", "style", "nav", "footer", "aside", "header", "iframe"]):
+                tag.extract()
+            
+            # Extract main content
+            main = soup.find('main') or soup.find('article') or soup.find('div', class_='mw-parser-output') or soup.body
+            
+            if not main:
+                return "Error: Could not find main content on page."
+            
+            text = main.get_text(separator='\n', strip=True)
+            lines = [l.strip() for l in text.splitlines() if l.strip()]
+            text = '\n'.join(lines)
+            
+            if len(text) < 50:
+                return f"Error: Page content too short ({len(text)} chars). May be blocked or empty."
+            
+            print(f"✓ Extracted {len(text)} characters from page")
+            
+            # Chunk and search
+            chunks = global_text_splitter.split_text(text)
+            
+            if not chunks:
+                return "Error: Could not process page content."
+            
+            print(f"✓ Created {len(chunks)} chunks")
+            
+            docs = [Document(page_content=c, metadata={"source": url}) for c in chunks]
+            
+            db = FAISS.from_documents(docs, global_embeddings)
+            retriever = db.as_retriever(search_kwargs={"k": 5})
+            retrieved = retriever.invoke(query)
+            
+            if not retrieved:
+                return f"No information found matching: '{query}'\nTry a different query or the information may not be on this page."
+            
+            print(f"✓ Found {len(retrieved)} relevant chunks")
+            
+            context = "\n\n---\n\n".join([f"[Section {i+1}]\n{d.page_content}" for i, d in enumerate(retrieved)])
+            
+            return truncate_if_needed(f"From {url}:\n\n{context}")
+
+        except requests.Timeout:
+            if attempt < max_retries - 1:
+                print(f"⚠️ Timeout, retrying... (attempt {attempt + 1}/{max_retries})")
+                time.sleep(2 ** attempt)
+                continue
+            return f"Error: Page request timed out after {max_retries} attempts."
+        except requests.RequestException as e:
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)
+                continue
+            return f"Error fetching page: {str(e)}"
+        except Exception as e:
+            return f"Error processing page: {str(e)}\n{traceback.format_exc()}"
+            
+def analyze_chess_position(args: str, state: AgentState) -> str:
+    """
+    Analyze chess position using Stockfish engine via lichess API or python-chess
+    Input format: "image_path|description" or just FEN notation
+    """
     try:
-        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
-        response = requests.get(url, headers=headers, timeout=20)
-        response.raise_for_status()
-        
-        soup = BeautifulSoup(response.text, 'html.parser')
-        
-        for tag in soup(["script", "style", "nav", "footer", "aside", "header", "iframe"]):
-            tag.extract()
-        
-        main = soup.find('main') or soup.find('article') or soup.body
-        
-        if not main:
-            return "Error: No main content found."
-        
-        text = main.get_text(separator='\n', strip=True)
-        lines = [l.strip() for l in text.splitlines() if l.strip()]
-        text = '\n'.join(lines)
-        
-        if len(text) < 50:
-            return f"Error: Content too short ({len(text)} chars)."
-        
-        chunks = global_text_splitter.split_text(text)
-        
-        if not chunks:
-            return "Error: Could not chunk text."
-        
-        docs = [Document(page_content=c, metadata={"source": url}) for c in chunks]
+        # Try to use python-chess with Stockfish
+        try:
+            import chess
+            import chess.engine
+            
+            # Check if we have an image to analyze first
+            if '|' in args and os.path.exists(args.split('|')[0]):
+                image_path = args.split('|')[0]
+                
+                # Use Gemini to extract FEN from image
+                print("📸 Extracting chess position from image...")
+                img = Image.open(image_path)
+                model = genai.GenerativeModel('gemini-2.0-flash-exp')
+                
+                fen_prompt = """Analyze this chess board image and provide the position in FEN notation.
+                
+                Important instructions:
+                1. Carefully identify each piece and its position
+                2. Determine whose turn it is (look for indicators in the image)
+                3. Return ONLY the FEN string, nothing else
+                4. Format: piece_placement active_color castling en_passant halfmove fullmove
+                
+                Example: rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1
+                
+                If it says "Black to move" or "Black's turn", use 'b' for active color.
+                If it says "White to move" or "White's turn", use 'w' for active color."""
+                
+                response = model.generate_content([fen_prompt, img])
+                fen = response.text.strip()
+                
+                # Clean up the FEN (remove markdown, explanations, etc.)
+                fen_lines = fen.split('\n')
+                for line in fen_lines:
+                    line = line.strip()
+                    # FEN should have spaces and slashes
+                    if '/' in line and ' ' in line and not line.startswith('#'):
+                        fen = line
+                        break
+                
+                print(f"📊 Extracted FEN: {fen}")
+            else:
+                # Direct FEN input
+                fen = args.strip()
+            
+            # Parse the position
+            try:
+                board = chess.Board(fen)
+            except Exception as e:
+                return f"N/A_REQUIRED: Invalid FEN notation - {str(e)}"
+            
+            # Try to use Stockfish engine
+            stockfish_paths = [
+                "/usr/games/stockfish",
+                "/usr/local/bin/stockfish",
+                "/opt/homebrew/bin/stockfish",
+                "stockfish",
+                "./stockfish"
+            ]
+            
+            engine_path = None
+            for path in stockfish_paths:
+                if os.path.exists(path) or path == "stockfish":
+                    engine_path = path
+                    break
+            
+            if not engine_path:
+                # Fallback to lichess API
+                print("⚠️ Stockfish not found locally, using Lichess API...")
+                return analyze_chess_via_lichess(board.fen(), state)
+            
+            # Use local Stockfish
+            with chess.engine.SimpleEngine.popen_uci(engine_path) as engine:
+                # Analyze position
+                info = engine.analyse(board, chess.engine.Limit(depth=20))
+                best_move = info.get("pv")[0] if "pv" in info else None
+                
+                if best_move:
+                    # Convert to algebraic notation
+                    san_move = board.san(best_move)
+                    
+                    # Get evaluation score
+                    score = info.get("score")
+                    score_str = ""
+                    if score:
+                        if score.is_mate():
+                            mate_in = score.relative.moves
+                            score_str = f" (Mate in {abs(mate_in)})"
+                        else:
+                            cp = score.relative.score()
+                            score_str = f" (Eval: {cp/100:.2f})"
+                    
+                    # Check if this move leads to checkmate
+                    board_copy = board.copy()
+                    board_copy.push(best_move)
+                    
+                    result = f"{san_move}{score_str}"
+                    
+                    if board_copy.is_checkmate():
+                        result += " - Checkmate!"
+                    elif board_copy.is_check():
+                        result += " - Check"
+                    
+                    print(f"♟️ Best move: {result}")
+                    return result
+                else:
+                    return "N/A_REQUIRED: Could not determine best move"
+                    
+        except ImportError:
+            print("⚠️ python-chess not installed, using Lichess API...")
+            # Extract FEN from image if needed
+            if '|' in args and os.path.exists(args.split('|')[0]):
+                image_path = args.split('|')[0]
+                img = Image.open(image_path)
+                model = genai.GenerativeModel('gemini-2.0-flash-exp')
+                
+                response = model.generate_content([
+                    "Extract the chess position in FEN notation. Return ONLY the FEN string.",
+                    img
+                ])
+                fen = response.text.strip()
+            else:
+                fen = args.strip()
+            
+            return analyze_chess_via_lichess(fen, state)
+            
+    except Exception as e:
+        state.add_failure('chess', str(e))
+        return f"N/A_REQUIRED: Chess analysis failed - {str(e)}"
+
+
+def analyze_chess_via_lichess(fen: str, state: AgentState) -> str:
+    """
+    Analyze chess position using Lichess cloud API
+    """
+    try:
+        # Lichess cloud evaluation API
+        url = "https://lichess.org/api/cloud-eval"
         
-        db = FAISS.from_documents(docs, global_embeddings)
-        retriever = db.as_retriever(search_kwargs={"k": 5})
-        retrieved = retriever.invoke(query)
+        # Clean FEN
+        fen = fen.strip().replace('```', '').replace('fen', '').strip()
         
-        if not retrieved:
-            return f"No relevant info found for: '{query}'"
+        params = {
+            "fen": fen,
+            "multiPv": 1  # Get best move only
+        }
         
-        context = "\n\n---\n\n".join([f"[Chunk {i+1}]\n{d.page_content}" for i, d in enumerate(retrieved)])
+        response = requests.get(url, params=params, timeout=10)
         
-        return truncate_if_needed(f"From {url}:\n\n{context}")
-
-    except requests.RequestException as e:
-        return f"Fetch error: {str(e)}"
+        if response.status_code == 200:
+            data = response.json()
+            
+            if "pvs" in data and len(data["pvs"]) > 0:
+                best_pv = data["pvs"][0]
+                
+                # Get the moves in UCI notation
+                moves = best_pv.get("moves", "").split()
+                if moves:
+                    # Convert UCI to SAN using python-chess if available
+                    try:
+                        import chess
+                        board = chess.Board(fen)
+                        uci_move = chess.Move.from_uci(moves[0])
+                        san_move = board.san(uci_move)
+                        
+                        # Get evaluation
+                        cp = best_pv.get("cp")
+                        mate = best_pv.get("mate")
+                        
+                        if mate is not None:
+                            eval_str = f" (Mate in {abs(mate)})"
+                        elif cp is not None:
+                            eval_str = f" (Eval: {cp/100:.2f})"
+                        else:
+                            eval_str = ""
+                        
+                        return f"{san_move}{eval_str}"
+                    except:
+                        # Return UCI move if can't convert
+                        return moves[0]
+                else:
+                    return "N/A_REQUIRED: No moves found in analysis"
+            else:
+                return "N/A_REQUIRED: Position not in Lichess cloud database"
+        else:
+            state.add_failure('lichess', f'HTTP {response.status_code}')
+            return f"N/A_REQUIRED: Lichess API error {response.status_code}"
+            
     except Exception as e:
-        return f"Scrape error: {str(e)}\n{traceback.format_exc()}"
-
+        state.add_failure('lichess', str(e))
+        return f"N/A_REQUIRED: Lichess analysis failed - {str(e)}"
 
 class FinalAnswerInput(BaseModel):
     answer: str = Field(description="Final answer - EXACTLY what was asked, nothing more")
@@ -761,7 +1121,7 @@ defined_tools = [
     
     # Specialized
     audio_transcription_tool,
-    analyze_image,  # NEW: Image analysis tool
+    analyze_image,  
     get_youtube_transcript,
     scrape_and_retrieve,