Added wikipedia search

requirements.txt

@@ -12,3 +12,6 @@ pandas
 gradio[oauth]
 openpyxl
 xlrd
+llama-index-tools-wikipedia
+llama-index-core
+wikipedia-api

test_wikipedia.py

@@ -0,0 +1,17 @@
+# test_wikipedia.py
+from tools.wikipedia_tools import search_wikipedia, get_wikipedia_page, wikipedia_summary
+
+# Test search
+print("=== Testing Wikipedia Search ===")
+result = search_wikipedia("Mercedes Sosa discography")
+print(f"Search result: {result[:200]}...")
+
+# Test specific page
+print("\n=== Testing Wikipedia Page Retrieval ===")
+result = get_wikipedia_page("Mercedes Sosa discography")
+print(f"Page result: {result[:200]}...")
+
+# Test summary
+print("\n=== Testing Wikipedia Summary ===")
+result = wikipedia_summary("Mercedes Sosa discography")
+print(f"Summary result: {result[:200]}...")

tools/langchain_tools.py

@@ -16,6 +16,7 @@ from .multimodal_tools import MultimodalTools, analyze_transcript as _analyze_tr
 from .search_tools import SearchTools
 from .math_tools import MathTools
 from .youtube_tools import YouTubeTools
+from .wikipedia_tools import search_wikipedia, get_wikipedia_page, wikipedia_summary
 
 # Initialize tool instances (now env vars are available)
 multimodal_tools = MultimodalTools()
@@ -249,6 +250,46 @@ def analyze_python_tool(file_path: str, question: str = "What is the final outpu
 # =============================================================================
 # TOOL COLLECTIONS FOR EASY IMPORT
 # =============================================================================
+@tool
+def analyze_youtube_frames(url: str, question: str = "Describe what happens in this video") -> str:
+    """Extract frames from YouTube video and analyze visual content"""
+    youtube_tools = YouTubeTools()
+    return youtube_tools.analyze_video_content(url, question)
+
+@tool
+def extract_video_slides(url: str) -> str:
+    """Extract and analyze slides from educational YouTube videos"""
+    youtube_tools = YouTubeTools()
+    results = youtube_tools.analyze_video_slides(url)
+    
+    if 'error' in results:
+        return results['error']
+    
+    # Format slide analysis for LLM
+    slide_content = []
+    for frame in results.get('frames_analyzed', []):
+        if 'slide' in frame.get('analysis', '').lower():
+            slide_content.append(f"Slide {frame['frame_number']}: {frame['analysis']}")
+    
+    if slide_content:
+        return "\n\n".join(slide_content)
+    else:
+        return results.get('analysis_summary', 'No slides detected in video')
+# Add Wikipedia tools
+@tool
+def search_wikipedia_tool(query: str, language: str = 'en') -> str:
+    """Search Wikipedia for information about a topic"""
+    return search_wikipedia(query, language)
+
+@tool
+def get_wikipedia_page_tool(page_title: str, language: str = 'en') -> str:
+    """Retrieve a specific Wikipedia page by title"""
+    return get_wikipedia_page(page_title, language)
+
+@tool
+def wikipedia_summary_tool(query: str, language: str = 'en') -> str:
+    """Get a concise Wikipedia summary about a topic"""
+    return wikipedia_summary(query, language)
 
 # Core tools (matching original template)
 CORE_TOOLS = [
@@ -266,8 +307,13 @@ CORE_TOOLS = [
 # Extended tools with new Excel functionality
 EXTENDED_TOOLS = CORE_TOOLS + [
     analyze_excel_tool,  # NEW: Excel/CSV analysis
+     analyze_youtube_frames,  # ✅ NEW: Frame extraction and analysis
+    extract_video_slides,    # ✅ NEW: Slide detection
     analyze_python_tool,
     search_news_tool,
+     search_wikipedia_tool,      # ✅ NEW: Wikipedia search
+    get_wikipedia_page_tool,    # ✅ NEW: Specific Wikipedia pages
+    wikipedia_summary_tool,     # ✅ NEW: Wikipedia summaries
     search_academic_tool,
     get_youtube_info,
     get_youtube_playlist_info,

tools/wikipedia_tools.py

@@ -0,0 +1,139 @@
+# tools/wikipedia_tools.py
+"""
+Wikipedia search tools using LlamaIndex's ready-made Wikipedia integration
+Based on search results showing WikipediaToolSpec usage
+"""
+
+from typing import Optional, List
+import logging
+from .utils import logger
+
+try:
+    from llama_index.tools.wikipedia import WikipediaToolSpec
+    WIKIPEDIA_AVAILABLE = True
+except ImportError:
+    logger.warning("LlamaIndex Wikipedia tools not available. Install with: pip install llama-index-tools-wikipedia")
+    WIKIPEDIA_AVAILABLE = False
+
+class WikipediaTools:
+    """Wikipedia search and page retrieval tools using LlamaIndex"""
+    
+    def __init__(self):
+        if not WIKIPEDIA_AVAILABLE:
+            raise ImportError("LlamaIndex Wikipedia tools not installed")
+        
+        # Initialize the LlamaIndex Wikipedia tool spec
+        self.tool_spec = WikipediaToolSpec()
+        logger.info("Wikipedia tools initialized successfully")
+    
+    def search_wikipedia(self, query: str, language: str = 'en') -> str:
+        """
+        Search Wikipedia for pages related to a query
+        Based on search results showing search_data method
+        
+        Args:
+            query: Search term
+            language: Wikipedia language (default: 'en')
+            
+        Returns:
+            Search results from Wikipedia
+        """
+        try:
+            logger.info(f"Searching Wikipedia for: {query}")
+            
+            # Use LlamaIndex's search_data method (from search results)
+            results = self.tool_spec.search_data(query=query, lang=language)
+            
+            if results:
+                logger.info(f"Found Wikipedia results for: {query}")
+                return results
+            else:
+                return f"No Wikipedia results found for: {query}"
+                
+        except Exception as e:
+            error_msg = f"Error searching Wikipedia: {str(e)}"
+            logger.error(error_msg)
+            return error_msg
+    
+    def get_wikipedia_page(self, page_title: str, language: str = 'en') -> str:
+        """
+        Retrieve a specific Wikipedia page
+        Based on search results showing load_data method
+        
+        Args:
+            page_title: Title of the Wikipedia page
+            language: Wikipedia language (default: 'en')
+            
+        Returns:
+            Content of the Wikipedia page
+        """
+        try:
+            logger.info(f"Retrieving Wikipedia page: {page_title}")
+            
+            # Use LlamaIndex's load_data method (from search results)
+            content = self.tool_spec.load_data(page=page_title, lang=language)
+            
+            if content:
+                logger.info(f"Successfully retrieved Wikipedia page: {page_title}")
+                return content
+            else:
+                return f"Wikipedia page not found: {page_title}"
+                
+        except Exception as e:
+            error_msg = f"Error retrieving Wikipedia page '{page_title}': {str(e)}"
+            logger.error(error_msg)
+            return error_msg
+    
+    def search_and_summarize(self, query: str, language: str = 'en') -> str:
+        """
+        Search Wikipedia and get a focused summary
+        Combines search and page retrieval for better results
+        """
+        try:
+            # First search for relevant pages
+            search_results = self.search_wikipedia(query, language)
+            
+            if "No Wikipedia results found" in search_results:
+                return search_results
+            
+            # Extract the first few sentences for a summary
+            # This gives us the most relevant information without overwhelming the LLM
+            lines = search_results.split('\n')
+            summary_lines = [line for line in lines[:10] if line.strip()]
+            summary = '\n'.join(summary_lines)
+            
+            # Truncate if too long (to stay within token limits)
+            if len(summary) > 2000:
+                summary = summary[:2000] + "..."
+            
+            return summary
+            
+        except Exception as e:
+            error_msg = f"Error in Wikipedia search and summarize: {str(e)}"
+            logger.error(error_msg)
+            return error_msg
+
+# Convenience functions for direct use
+def search_wikipedia(query: str, language: str = 'en') -> str:
+    """Standalone function to search Wikipedia"""
+    if not WIKIPEDIA_AVAILABLE:
+        return "Wikipedia tools not available. Please install llama-index-tools-wikipedia"
+    
+    tools = WikipediaTools()
+    return tools.search_wikipedia(query, language)
+
+def get_wikipedia_page(page_title: str, language: str = 'en') -> str:
+    """Standalone function to get a Wikipedia page"""
+    if not WIKIPEDIA_AVAILABLE:
+        return "Wikipedia tools not available. Please install llama-index-tools-wikipedia"
+    
+    tools = WikipediaTools()
+    return tools.get_wikipedia_page(page_title, language)
+
+def wikipedia_summary(query: str, language: str = 'en') -> str:
+    """Standalone function to get a Wikipedia summary"""
+    if not WIKIPEDIA_AVAILABLE:
+        return "Wikipedia tools not available. Please install llama-index-tools-wikipedia"
+    
+    tools = WikipediaTools()
+    return tools.search_and_summarize(query, language)

tools/youtube_tools.py

@@ -12,6 +12,13 @@ import time
 import logging
 from .utils import logger, validate_file_exists
 
+import cv2
+import tempfile
+import os
+from typing import Optional, Dict, Any, List
+from PIL import Image
+import numpy as np
+
 class YouTubeTools:
     """YouTube tools with improved error handling and network resilience"""
     
@@ -285,6 +292,293 @@ class YouTubeTools:
         except Exception as e:
             logger.error(f"Failed to get qualities for {url}: {e}")
             return None
+    def extract_and_analyze_frames(self, url: str, num_frames: int = 5, analysis_question: str = "Describe what you see in this frame") -> Dict[str, Any]:
+        """
+        Extract key frames and analyze video content visually
+        Based on search results showing OpenCV and MoviePy approaches
+        """
+        logger.info(f"Starting frame extraction for {url} with {num_frames} frames")
+        
+        results = {
+            'video_info': None,
+            'frames_analyzed': [],
+            'extraction_method': None,
+            'total_frames_extracted': 0,
+            'analysis_summary': None
+        }
+        
+        try:
+            # Get video info first
+            video_info = self.get_video_info(url)
+            if not video_info:
+                return {'error': 'Could not retrieve video information'}
+            
+            results['video_info'] = {
+                'title': video_info.get('title', 'Unknown'),
+                'duration': video_info.get('length', 0),
+                'author': video_info.get('author', 'Unknown')
+            }
+            
+            # Strategy 1: Try full video download and OpenCV frame extraction (local environment)
+            frame_paths = self._strategy_1_opencv_extraction(url, num_frames)
+            
+            if frame_paths:
+                results['extraction_method'] = 'OpenCV Video Download'
+                results['frames_analyzed'] = self._analyze_extracted_frames(frame_paths, analysis_question)
+                results['total_frames_extracted'] = len(frame_paths)
+                
+                # Cleanup downloaded video and frames
+                self._cleanup_files(frame_paths)
+            else:
+                # Strategy 2: Thumbnail analysis fallback (HF Spaces compatible)
+                thumbnail_analysis = self._strategy_2_thumbnail_analysis(url, analysis_question)
+                results['extraction_method'] = 'Thumbnail Analysis (Fallback)'
+                results['frames_analyzed'] = [thumbnail_analysis]
+                results['total_frames_extracted'] = 1
+            
+            # Generate overall summary
+            results['analysis_summary'] = self._generate_frame_analysis_summary(results)
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"Error in frame extraction: {e}")
+            return {'error': f'Frame extraction failed: {str(e)}'}
+    
+    def _strategy_1_opencv_extraction(self, url: str, num_frames: int) -> List[str]:
+        """
+        Strategy 1: Download video and extract frames using OpenCV
+        Based on search result [2] OpenCV approach
+        """
+        try:
+            # Check if we're in a restricted environment (HF Spaces)
+            if os.getenv("SPACE_ID"):
+                logger.info("Restricted environment detected, skipping video download")
+                return []
+            
+            # Download video to temporary location
+            temp_dir = tempfile.mkdtemp()
+            video_path = self.download_video(url, output_path=temp_dir, resolution='lowest')
+            
+            if not video_path or not os.path.exists(video_path):
+                logger.warning("Video download failed")
+                return []
+            
+            # Extract frames using OpenCV (based on search results)
+            frame_paths = self._extract_frames_opencv(video_path, num_frames)
+            
+            # Cleanup video file (keep frame files for analysis)
+            if os.path.exists(video_path):
+                os.remove(video_path)
+            
+            return frame_paths
+            
+        except Exception as e:
+            logger.error(f"Strategy 1 failed: {e}")
+            return []
+    
+    def _extract_frames_opencv(self, video_path: str, num_frames: int) -> List[str]:
+        """
+        Extract frames using OpenCV - implementation from search results
+        Based on search result [2] and [4] showing cv2.VideoCapture approach
+        """
+        frame_paths = []
+        
+        try:
+            # Load video using OpenCV (from search results)
+            cap = cv2.VideoCapture(video_path)
+            
+            if not cap.isOpened():
+                logger.error("Error: Could not open video with OpenCV")
+                return []
+            
+            # Get total frames and calculate intervals (from search results)
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            logger.info(f"Total frames in video: {total_frames}")
+            
+            if total_frames == 0:
+                return []
+            
+            # Calculate frame intervals to get evenly distributed frames
+            if num_frames >= total_frames:
+                frame_intervals = list(range(total_frames))
+            else:
+                frame_intervals = [int(total_frames * i / (num_frames - 1)) for i in range(num_frames)]
+                frame_intervals[-1] = total_frames - 1  # Ensure we get the last frame
+            
+            # Extract frames at calculated intervals (based on search results pattern)
+            for i, frame_num in enumerate(frame_intervals):
+                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_num)
+                ret, frame = cap.read()
+                
+                if ret:
+                    # Save frame as temporary file (from search results)
+                    frame_filename = tempfile.mktemp(suffix=f'_frame_{i}.jpg')
+                    cv2.imwrite(frame_filename, frame)
+                    frame_paths.append(frame_filename)
+                    logger.debug(f"Extracted frame {i} at position {frame_num}")
+                else:
+                    logger.warning(f"Failed to read frame at position {frame_num}")
+            
+            cap.release()
+            logger.info(f"Successfully extracted {len(frame_paths)} frames using OpenCV")
+            return frame_paths
+            
+        except Exception as e:
+            logger.error(f"OpenCV frame extraction failed: {e}")
+            return []
+    
+    def _strategy_2_thumbnail_analysis(self, url: str, analysis_question: str) -> Dict[str, Any]:
+        """
+        Strategy 2: Analyze thumbnail when video download isn't possible
+        Fallback for HF Spaces environment
+        """
+        try:
+            from .multimodal_tools import MultimodalTools
+            multimodal = MultimodalTools()
+            
+            # Get video info for thumbnail
+            video_info = self.get_video_info(url)
+            if not video_info or not video_info.get('thumbnail_url'):
+                return {'error': 'No thumbnail available'}
+            
+            # Download and analyze thumbnail
+            thumbnail_url = video_info['thumbnail_url']
+            
+            # Download thumbnail to temporary file
+            import requests
+            response = requests.get(thumbnail_url, timeout=10)
+            response.raise_for_status()
+            
+            with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp_file:
+                tmp_file.write(response.content)
+                thumbnail_path = tmp_file.name
+            
+            # Analyze thumbnail
+            analysis = multimodal.analyze_image(
+                thumbnail_path, 
+                f"This is a thumbnail from a YouTube video. {analysis_question}"
+            )
+            
+            # Cleanup
+            os.unlink(thumbnail_path)
+            
+            return {
+                'frame_number': 0,
+                'timestamp': 'thumbnail',
+                'analysis': analysis,
+                'extraction_method': 'thumbnail'
+            }
+            
+        except Exception as e:
+            logger.error(f"Thumbnail analysis failed: {e}")
+            return {'error': f'Thumbnail analysis failed: {str(e)}'}
+    
+    def _analyze_extracted_frames(self, frame_paths: List[str], analysis_question: str) -> List[Dict[str, Any]]:
+        """
+        Analyze extracted frames using multimodal AI
+        """
+        analyzed_frames = []
+        
+        try:
+            from .multimodal_tools import MultimodalTools
+            multimodal = MultimodalTools()
+            
+            for i, frame_path in enumerate(frame_paths):
+                try:
+                    analysis = multimodal.analyze_image(frame_path, analysis_question)
+                    
+                    analyzed_frames.append({
+                        'frame_number': i,
+                        'timestamp': f'frame_{i}',
+                        'analysis': analysis,
+                        'extraction_method': 'opencv'
+                    })
+                    
+                except Exception as e:
+                    logger.warning(f"Failed to analyze frame {i}: {e}")
+                    analyzed_frames.append({
+                        'frame_number': i,
+                        'timestamp': f'frame_{i}',
+                        'analysis': f'Analysis failed: {str(e)}',
+                        'extraction_method': 'opencv'
+                    })
+            
+            return analyzed_frames
+            
+        except Exception as e:
+            logger.error(f"Frame analysis failed: {e}")
+            return []
+    
+    def _generate_frame_analysis_summary(self, results: Dict[str, Any]) -> str:
+        """Generate overall summary of frame analysis"""
+        try:
+            if not results.get('frames_analyzed'):
+                return "No frames were successfully analyzed"
+            
+            # Combine all frame analyses
+            all_analyses = []
+            for frame in results['frames_analyzed']:
+                if isinstance(frame, dict) and 'analysis' in frame:
+                    all_analyses.append(frame['analysis'])
+            
+            if not all_analyses:
+                return "No valid frame analyses found"
+            
+            # Use multimodal AI to create summary
+            from .multimodal_tools import MultimodalTools
+            multimodal = MultimodalTools()
+            
+            combined_text = "\n\n".join([f"Frame {i}: {analysis}" for i, analysis in enumerate(all_analyses)])
+            
+            summary_prompt = f"""
+Based on these frame analyses from a video titled "{results['video_info']['title']}", 
+create a comprehensive summary of the video's visual content:
+
+{combined_text}
+
+Provide a concise summary highlighting the main visual elements, actions, and themes.
+"""
+            
+            summary = multimodal._make_openrouter_request({
+                "model": multimodal.text_model,
+                "messages": [{"role": "user", "content": summary_prompt}],
+                "temperature": 0,
+                "max_tokens": 512
+            })
+            
+            return summary
+            
+        except Exception as e:
+            logger.error(f"Summary generation failed: {e}")
+            return f"Summary generation failed: {str(e)}"
+    
+    def _cleanup_files(self, file_paths: List[str]):
+        """Clean up temporary files"""
+        for file_path in file_paths:
+            try:
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+            except Exception as e:
+                logger.warning(f"Could not remove {file_path}: {e}")
+    
+    # Convenience method for specific use cases
+    def analyze_video_slides(self, url: str) -> Dict[str, Any]:
+        """Specialized method for analyzing educational videos with slides"""
+        return self.extract_and_analyze_frames(
+            url, 
+            num_frames=8,
+            analysis_question="Is this a presentation slide? If yes, extract the main title and key points. If no, describe the visual content."
+        )
+    
+    def analyze_video_content(self, url: str, question: str) -> str:
+        """Analyze video content and answer specific questions"""
+        frame_results = self.extract_and_analyze_frames(url, num_frames=5, analysis_question=question)
+        
+        if 'error' in frame_results:
+            return frame_results['error']
+        
+        return frame_results.get('analysis_summary', 'No analysis available')
 
 # Convenience functions (unchanged)
 def get_video_info(url: str) -> Optional[Dict[str, Any]]: