Update app.py

app.py

@@ -1,827 +1,125 @@
-import os
-import gradio as gr
-import requests
-import inspect
-import time
-import pandas as pd
-from smolagents import DuckDuckGoSearchTool
-import threading
-from typing import Dict, List, Optional, Tuple, Union
-import json
-from huggingface_hub import InferenceClient
-import base64
-from PIL import Image
-import io
-import tempfile
-import urllib.parse
-from pathlib import Path
-import re
-from bs4 import BeautifulSoup
-import mimetypes
-
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-# --- Global Cache for Answers ---
-cached_answers = {}
-cached_questions = []
-processing_status = {"is_processing": False, "progress": 0, "total": 0}
-
-# --- Web Content Fetcher ---
-class WebContentFetcher:
-    def __init__(self, debug: bool = True):
-        self.debug = debug
-        self.session = requests.Session()
-        self.session.headers.update({
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        })
-        
-    def extract_urls_from_text(self, text: str) -> List[str]:
-        """Extract URLs from text using regex."""
-        url_pattern = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
-        urls = re.findall(url_pattern, text)
-        return list(set(urls))  # Remove duplicates
-    
-    def fetch_url_content(self, url: str) -> Dict[str, str]:
-        """
-        Fetch content from a URL and extract text, handling different content types.
-        Returns a dictionary with 'content', 'title', 'content_type', and 'error' keys.
-        """
-        try:
-            # Clean the URL
-            url = url.strip()
-            if not url.startswith(('http://', 'https://')):
-                url = 'https://' + url
-            
-            if self.debug:
-                print(f"Fetching URL: {url}")
-            
-            response = self.session.get(url, timeout=30, allow_redirects=True)
-            response.raise_for_status()
-            
-            content_type = response.headers.get('content-type', '').lower()
-            
-            result = {
-                'url': url,
-                'content_type': content_type,
-                'title': '',
-                'content': '',
-                'error': None
-            }
-            
-            # Handle different content types
-            if 'text/html' in content_type:
-                # Parse HTML content
-                soup = BeautifulSoup(response.content, 'html.parser')
-                
-                # Extract title
-                title_tag = soup.find('title')
-                result['title'] = title_tag.get_text().strip() if title_tag else 'No title'
-                
-                # Remove script and style elements
-                for script in soup(["script", "style"]):
-                    script.decompose()
-                
-                # Extract text content
-                text_content = soup.get_text()
-                
-                # Clean up text
-                lines = (line.strip() for line in text_content.splitlines())
-                chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
-                text_content = ' '.join(chunk for chunk in chunks if chunk)
-                
-                # Limit content length
-                if len(text_content) > 8000:
-                    text_content = text_content[:8000] + "... (truncated)"
-                
-                result['content'] = text_content
-                
-            elif 'text/plain' in content_type:
-                # Handle plain text
-                text_content = response.text
-                if len(text_content) > 8000:
-                    text_content = text_content[:8000] + "... (truncated)"
-                result['content'] = text_content
-                result['title'] = f"Text document from {url}"
-                
-            elif 'application/json' in content_type:
-                # Handle JSON content
-                try:
-                    json_data = response.json()
-                    result['content'] = json.dumps(json_data, indent=2)[:8000]
-                    result['title'] = f"JSON document from {url}"
-                except:
-                    result['content'] = response.text[:8000]
-                    result['title'] = f"JSON document from {url}"
-                    
-            elif any(x in content_type for x in ['application/pdf', 'application/msword', 'application/vnd.openxmlformats']):
-                # Handle document files
-                result['content'] = f"Document file detected ({content_type}). Content extraction for this file type is not implemented."
-                result['title'] = f"Document from {url}"
-                
-            else:
-                # Handle other content types
-                if response.text:
-                    content = response.text[:8000]
-                    result['content'] = content
-                    result['title'] = f"Content from {url}"
-                else:
-                    result['content'] = f"Non-text content detected ({content_type})"
-                    result['title'] = f"File from {url}"
-            
-            if self.debug:
-                print(f"Successfully fetched content from {url}: {len(result['content'])} characters")
-            
-            return result
-            
-        except requests.exceptions.RequestException as e:
-            error_msg = f"Failed to fetch {url}: {str(e)}"
-            if self.debug:
-                print(error_msg)
-            return {
-                'url': url,
-                'content_type': 'error',
-                'title': f"Error fetching {url}",
-                'content': '',
-                'error': error_msg
-            }
-        except Exception as e:
-            error_msg = f"Unexpected error fetching {url}: {str(e)}"
-            if self.debug:
-                print(error_msg)
-            return {
-                'url': url,
-                'content_type': 'error',
-                'title': f"Error fetching {url}",
-                'content': '',
-                'error': error_msg
-            }
-    
-    def fetch_multiple_urls(self, urls: List[str]) -> List[Dict[str, str]]:
-        """Fetch content from multiple URLs."""
-        results = []
-        for url in urls[:5]:  # Limit to 5 URLs to avoid excessive processing
-            result = self.fetch_url_content(url)
-            results.append(result)
-            time.sleep(1)  # Be respectful to servers
-        return results
-
-# --- File Processing Utility ---
-def save_attachment_to_file(attachment_data: Union[str, bytes, dict], temp_dir: str, file_name: str = None) -> Optional[str]:
+def _detect_and_process_direct_attachments(self, file_name: str) -> Tuple[List[str], List[str], List[str]]:
     """
-    Save attachment data to a temporary file.
-    Returns the local file path if successful, None otherwise.
+    Detect and process a single attachment directly attached to a question (not as a URL).
+    Returns (image_files, audio_files, code_files)
     """
+    image_files = []
+    audio_files = []
+    code_files = []
+
+    if not file_name:
+        return image_files, audio_files, code_files
+
     try:
-        # Determine file name and extension
-        if not file_name:
-            file_name = f"attachment_{int(time.time())}"
-        
-        # Handle different data types
-        if isinstance(attachment_data, dict):
-            # Handle dict with file data
-            if 'data' in attachment_data:
-                file_data = attachment_data['data']
-                file_type = attachment_data.get('type', '').lower()
-                original_name = attachment_data.get('name', file_name)
-            elif 'content' in attachment_data:
-                file_data = attachment_data['content']
-                file_type = attachment_data.get('mime_type', '').lower()
-                original_name = attachment_data.get('filename', file_name)
-            else:
-                # Try to use the dict as file data directly
-                file_data = str(attachment_data)
-                file_type = ''
-                original_name = file_name
-                
-            # Use original name if available
-            if original_name and original_name != file_name:
-                file_name = original_name
-                
-        elif isinstance(attachment_data, str):
-            # Could be base64 encoded data or plain text
-            file_data = attachment_data
-            file_type = ''
-            
-        elif isinstance(attachment_data, bytes):
-            # Binary data
-            file_data = attachment_data
-            file_type = ''
-            
-        else:
-            print(f"Unknown attachment data type: {type(attachment_data)}")
-            return None
-        
-        # Ensure file has an extension
-        if '.' not in file_name:
-            # Try to determine extension from type
-            if 'image' in file_type:
-                if 'jpeg' in file_type or 'jpg' in file_type:
-                    file_name += '.jpg'
-                elif 'png' in file_type:
-                    file_name += '.png'
-                else:
-                    file_name += '.img'
-            elif 'audio' in file_type:
-                if 'mp3' in file_type:
-                    file_name += '.mp3'
-                elif 'wav' in file_type:
-                    file_name += '.wav'
-                else:
-                    file_name += '.audio'
-            elif 'python' in file_type or 'text' in file_type:
-                file_name += '.py'
-            else:
-                file_name += '.file'
-        
-        file_path = os.path.join(temp_dir, file_name)
-        
-        # Save the file
-        if isinstance(file_data, str):
-            # Try to decode if it's base64
-            try:
-                # Check if it looks like base64
-                if len(file_data) > 100 and '=' in file_data[-5:]:
-                    decoded_data = base64.b64decode(file_data)
-                    with open(file_path, 'wb') as f:
-                        f.write(decoded_data)
-                else:
-                    # Plain text
-                    with open(file_path, 'w', encoding='utf-8') as f:
-                        f.write(file_data)
-            except:
-                # If base64 decode fails, save as text
-                with open(file_path, 'w', encoding='utf-8') as f:
-                    f.write(file_data)
-        else:
-            # Binary data
-            with open(file_path, 'wb') as f:
-                f.write(file_data)
-        
-        print(f"Saved attachment: {file_path}")
-        return file_path
+        # Construct the file path (assuming file is in current directory)
+        file_path = os.path.join(os.getcwd(), file_name)
         
-    except Exception as e:
-        print(f"Failed to save attachment: {e}")
-        return None
+        # Check if file exists
+        if not os.path.exists(file_path):
+            if self.debug:
+                print(f"File not found: {file_path}")
+            return image_files, audio_files, code_files
 
-# --- Code Processing Tool ---
-class CodeAnalysisTool:
-    def __init__(self, model_name: str = "meta-llama/Llama-3.1-8B-Instruct"):
-        self.client = InferenceClient(model=model_name, provider="sambanova")
-        
-    def analyze_code(self, code_path: str) -> str:
-        """
-        Analyze Python code and return insights.
-        """
-        try:
-            with open(code_path, 'r', encoding='utf-8') as f:
-                code_content = f.read()
-            
-            # Limit code length for analysis
-            if len(code_content) > 5000:
-                code_content = code_content[:5000] + "\n... (truncated)"
-            
-            analysis_prompt = f"""Analyze this Python code and provide a concise summary of:
-1. What the code does (main functionality)
-2. Key functions/classes
-3. Any notable patterns or issues
-4. Input/output behavior if applicable
+        # Get file extension
+        file_ext = Path(file_name).suffix.lower()
 
-Code:
-```python
-{code_content}
-```
+        # Determine category
+        is_image = ( 
+            file_ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.tiff']
+        )
+        is_audio = ( 
+            file_ext in ['.mp3', '.wav', '.m4a', '.ogg', '.flac', '.aac']
+        )
+        is_code = (
+            file_ext in ['.py', '.txt', '.js', '.html', '.css', '.json', '.xml', '.md', '.c', '.cpp', '.java']
+        )
 
-Provide a brief, focused analysis:"""
+        # Categorize the file
+        if is_image:
+            image_files.append(file_path)
+        elif is_audio:
+            audio_files.append(file_path)
+        elif is_code:
+            code_files.append(file_path)
+        else:
+            # Default to code/text for unknown types
+            code_files.append(file_path)
 
-            messages = [{"role": "user", "content": analysis_prompt}]
-            response = self.client.chat_completion(
-                messages=messages,
-                max_tokens=500,
-                temperature=0.3
-            )
-            
-            return response.choices[0].message.content.strip()
-            
-        except Exception as e:
-            return f"Code analysis failed: {e}"
+        if self.debug:
+            print(f"Processed file: {file_name} -> {'image' if is_image else 'audio' if is_audio else 'code'}")
 
-# --- Image Processing Tool ---
-class ImageAnalysisTool:
-    def __init__(self, model_name: str = "microsoft/Florence-2-large"):
-        self.client = InferenceClient(model=model_name)
-        
-    def analyze_image(self, image_path: str, prompt: str = "Describe this image in detail") -> str:
-        """
-        Analyze an image and return a description.
-        """
-        try:
-            # Open and process the image
-            with open(image_path, "rb") as f:
-                image_bytes = f.read()
-            
-            # Use the vision model to analyze the image
-            response = self.client.image_to_text(
-                image=image_bytes,
-                model="microsoft/Florence-2-large"
-            )
-            
-            return response.get("generated_text", "Could not analyze image")
-            
-        except Exception as e:
-            try:
-                # Fallback: use a different vision model
-                response = self.client.image_to_text(
-                    image=image_bytes,
-                    model="Salesforce/blip-image-captioning-large"
-                )
-                return response.get("generated_text", f"Image analysis error: {e}")
-            except:
-                return f"Image analysis failed: {e}"
+    except Exception as e:
+        if self.debug:
+            print(f"Error processing attachment {file_name}: {e}")
 
-    def extract_text_from_image(self, image_path: str) -> str:
-        """
-        Extract text from an image using OCR.
-        """
-        try:
-            with open(image_path, "rb") as f:
-                image_bytes = f.read()
-            
-            # Use an OCR model
-            response = self.client.image_to_text(
-                image=image_bytes,
-                model="microsoft/trocr-base-printed"
-            )
+    if self.debug:
+        print(f"Processed attachment: {len(image_files)} images, {len(audio_files)} audio, {len(code_files)} code files")
             
-            return response.get("generated_text", "No text found in image")
-            
-        except Exception as e:
-            return f"OCR failed: {e}"
+    return image_files, audio_files, code_files
 
-# --- Audio Processing Tool ---
-class AudioTranscriptionTool:
-    def __init__(self, model_name: str = "openai/whisper-large-v3"):
-        self.client = InferenceClient(model=model_name)
-        
-    def transcribe_audio(self, audio_path: str) -> str:
-        """
-        Transcribe audio file to text.
-        """
-        try:
-            with open(audio_path, "rb") as f:
-                audio_bytes = f.read()
-            
-            # Use Whisper for transcription
-            response = self.client.automatic_speech_recognition(
-                audio=audio_bytes
-            )
-            
-            return response.get("text", "Could not transcribe audio")
-            
-        except Exception as e:
-            try:
-                # Fallback to a different ASR model
-                response = self.client.automatic_speech_recognition(
-                    audio=audio_bytes,
-                    model="facebook/wav2vec2-large-960h-lv60-self"
-                )
-                return response.get("text", f"Audio transcription error: {e}")
-            except:
-                return f"Audio transcription failed: {e}"
+def process_question_with_attachments(self, question_data: dict) -> str:
+    """
+    Process a question that may have attachments and URLs.
+    """
+    question_text = question_data.get('question', '')          
+    if self.debug:
+        print(f"Question data keys: {list(question_data.keys())}")
+        print(f"\n1. Processing question with potential attachments and URLs: {question_text[:300]}...")
 
-# --- Enhanced Intelligent Agent with Direct Attachment Processing ---
-class IntelligentAgent:
-    def __init__(self, debug: bool = True, model_name: str = "meta-llama/Llama-3.1-8B-Instruct"):
-        self.search = DuckDuckGoSearchTool()
-        self.client = InferenceClient(model=model_name, provider="sambanova")
-        self.image_tool = ImageAnalysisTool()
-        self.audio_tool = AudioTranscriptionTool()
-        self.code_tool = CodeAnalysisTool(model_name)
-        self.web_fetcher = WebContentFetcher(debug)
-        self.debug = debug
+    try:
+        # Detect and process URLs
         if self.debug:
-            print(f"IntelligentAgent initialized with model: {model_name}")
-
-    def _chat_completion(self, prompt: str, max_tokens: int = 500, temperature: float = 0.3) -> str:
-        """
-        Use chat completion instead of text generation to avoid provider compatibility issues.
-        """
-        try:
-            messages = [{"role": "user", "content": prompt}]
-            
-            # Try chat completion first
-            try:
-                response = self.client.chat_completion(
-                    messages=messages,
-                    max_tokens=max_tokens,
-                    temperature=temperature
-                )
-                return response.choices[0].message.content.strip()
-            except Exception as chat_error:
-                if self.debug:
-                    print(f"Chat completion failed: {chat_error}, trying text generation...")
-                
-                # Fallback to text generation
-                response = self.client.conversational(
-                    prompt,
-                    max_new_tokens=max_tokens,
-                    temperature=temperature,
-                    do_sample=temperature > 0
-                )
-                return response.strip()
-                
-        except Exception as e:
-            if self.debug:
-                print(f"Both chat completion and text generation failed: {e}")
-            raise e
-
-    def _extract_and_process_urls(self, question_text: str) -> str:
-        """
-        Extract URLs from question text and fetch their content.
-        Returns formatted content from all URLs.
-        """
-        urls = self.web_fetcher.extract_urls_from_text(question_text)
+            print(f"2. Detecting and processing URLs...")
         
-        if not urls:
-            return ""
+        url_context = self._extract_and_process_urls(question_text)
         
+        if self.debug and url_context:
+            print(f"URL context found: {len(url_context)} characters")
+    except Exception as e:
         if self.debug:
-            print(f"...Found {len(urls)} URLs in question: {urls}")
-        
-        url_contents = self.web_fetcher.fetch_multiple_urls(urls)
+            print(f"Error extracting URLs: {e}")
+        url_context = ""
         
-        if not url_contents:
-            return ""
-        
-        # Format the content
-        formatted_content = []
-        for content_data in url_contents:
-            if content_data['error']:
-                formatted_content.append(f"URL: {content_data['url']}\nError: {content_data['error']}")
-            else:
-                formatted_content.append(
-                    f"URL: {content_data['url']}\n"
-                    f"Title: {content_data['title']}\n"
-                    f"Content Type: {content_data['content_type']}\n"
-                    f"Content: {content_data['content']}"
-                )
-        
-        return "\n\n" + "="*50 + "\n".join(formatted_content) + "\n" + "="*50
-
-    def _detect_and_process_direct_attachments(self, file_name: str) -> Tuple[List[str], List[str], List[str]]:
-        """
-        Detect and process a single attachment directly attached to a question (not as a URL).
-        Returns (image_files, audio_files, code_files)
-        """
-        image_files = []
-        audio_files = []
-        code_files = []
-
-        try:
-        # Here, file_type should ideally come from metadata or inferred from content — 
-        # since only attachment_name is passed, we'll rely on the file extension.
-            # Get file extension
-            file_ext = Path(file_name).suffix.lower()
-
-            # Determine category
-            is_image = ( 
-            file_ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.tiff']
-            )
-            is_audio = ( 
-            file_ext in ['.mp3', '.wav', '.m4a', '.ogg', '.flac', '.aac']
-            )
-            is_code = (
-            file_ext in ['.py', '.txt', '.js', '.html', '.css', '.json', '.xml']
-            )
-
-            # Categorize the file
-            if is_image:
-                image_files.append(file_path)
-            elif is_audio:
-                audio_files.append(file_path)
-            elif is_code:
-                code_files.append(file_path)
-            else:
-                # Default to code/text for unknown types
-                code_files.append(file_path)
-
-        except Exception as e:
-            if getattr(self, 'debug', False):
-                print(f"Error processing attachment {file_name}: {e}")
-
-        if getattr(self, 'debug', False):
-            print(f"...Processed attachment: {len(image_files)} images, {len(audio_files)} audio, {len(code_files)} code files")
-                
-        return image_files, audio_files, code_files
-
-    def _process_attachments(self, image_files: List[str] = None, audio_files: List[str] = None, code_files: List[str] = None) -> str:
-        """
-        Process all types of attachments and return their content as text.
-        """
-        attachment_content = []
-        
-        # Process code files
-        if code_files:
-            for code_file in code_files:
-                if code_file and os.path.exists(code_file):
-                    try:
-                        # First, include the raw code content (truncated)
-                        with open(code_file, 'r', encoding='utf-8') as f:
-                            code_content = f.read()
-                        
-                        if len(code_content) > 1000:
-                            code_preview = code_content[:1000] + "\n... (truncated)"
-                        else:
-                            code_preview = code_content
-                        
-                        attachment_content.append(f"Code File Content:\n```python\n{code_preview}\n```")
-                        
-                        # Then add analysis
-                        code_analysis = self.code_tool.analyze_code(code_file)
-                        attachment_content.append(f"Code Analysis: {code_analysis}")
-                        
-                    except Exception as e:
-                        attachment_content.append(f"Error processing code file {code_file}: {e}")
-        
-        # Process images
-        if image_files:
-            for image_file in image_files:
-                if image_file and os.path.exists(image_file):
-                    try:
-                        # Analyze the image
-                        image_description = self.image_tool.analyze_image(image_file)
-                        attachment_content.append(f"Image Analysis: {image_description}")
-                        
-                        # Try to extract text from image
-                        extracted_text = self.image_tool.extract_text_from_image(image_file)
-                        if extracted_text and "No text found" not in extracted_text:
-                            attachment_content.append(f"Text from Image: {extracted_text}")
-                            
-                    except Exception as e:
-                        attachment_content.append(f"Error processing image {image_file}: {e}")
-        
-        # Process audio files
-        if audio_files:
-            for audio_file in audio_files:
-                if audio_file and os.path.exists(audio_file):
-                    try:
-                        # Transcribe the audio
-                        transcription = self.audio_tool.transcribe_audio(audio_file)
-                        attachment_content.append(f"Audio Transcription: {transcription}")
-                        
-                    except Exception as e:
-                        attachment_content.append(f"Error processing audio {audio_file}: {e}")
+    try:    
+        # Detect and download attachments
+        if self.debug:
+            print(f"3. Searching for images, audio or code attachments...")
         
-        return "\n\n".join(attachment_content) if attachment_content else ""
-
-    def _should_search(self, question: str, attachment_context: str = "", url_context: str = "") -> bool:
-        """
-        Use LLM to determine if search is needed for the question, considering attachment and URL context.
-        Returns True if search is recommended, False otherwise.
-        """
-        decision_prompt = f"""Analyze this question and decide if it requires real-time information, recent data, or specific facts that might not be in your training data.
-
-SEARCH IS NEEDED for:
-- Current events, news, recent developments
-- Real-time data (weather, stock prices, sports scores)
-- Specific factual information that changes frequently
-- Recent product releases, company information
-- Current status of people, organizations, or projects
-- Location-specific current information
-
-SEARCH IS NOT NEEDED for:
-- General knowledge questions
-- Mathematical calculations
-- Programming concepts and syntax
-- Historical facts (older than 1 year)
-- Definitions of well-established concepts
-- How-to instructions for common tasks
-- Creative writing or opinion-based responses
-- Questions that can be answered from attached files (code, images, audio)
-- Questions that can be answered from URL content provided
-- Code analysis, debugging, or explanation questions
-- Questions about uploaded or linked content
-
-Question: "{question}"
-
-{f"Attachment Context Available: {attachment_context[:1000]}..." if attachment_context else "No attachment context available."}
-
-{f"URL Content Available: {url_context[:1000]}..." if url_context else "No URL content available."}
-
-If you cannot provide an answer, reply with "NO_SEARCH". Respond with only "SEARCH" or "NO_SEARCH" followed by a brief reason (max 20 words).
-
-Example responses:
-- "SEARCH - Current weather data needed"
-- "NO_SEARCH - Mathematical concept, general knowledge sufficient"
-- "NO_SEARCH - Can be answered from attached code/image/URL content"
-"""
-
-        try:
-            response = self._chat_completion(decision_prompt, max_tokens=50, temperature=0.1)
-            
-            decision = response.strip().upper()
-            should_search = decision.startswith("SEARCH")
-            time.sleep(5)
-            
-            if self.debug:
-                print(f"4. Decision regarding the search: {decision}")
-                
-            return should_search
+        attachment_name = question_data.get('file_name', '')
+        if self.debug:
+            print(f"Attachment name from question_data: '{attachment_name}'")
             
-        except Exception as e:
-            if self.debug:
-                print(f"Error in search decision: {e}, defaulting to no search for questions with context")
-            # Default to no search if decision fails and there is context available
-            return len(attachment_context) == 0 and len(url_context) == 0
-
-    def _answer_with_llm(self, question: str, attachment_context: str = "", url_context: str = "") -> str:
-        """
-        Generate answer using LLM without search, considering attachment and URL context.
-        """
-        context_sections = []
+        image_files, audio_files, code_files = self._detect_and_process_direct_attachments(attachment_name)
         
-        if attachment_context:
-            context_sections.append(f"Attachment Context:\n{attachment_context}")
+        # Process attachments to get context
+        attachment_context = self._process_attachments(image_files, audio_files, code_files)
         
-        if url_context:
-            context_sections.append(f"URL Content:\n{url_context}")
-        
-        context_section = "\n\n".join(context_sections) if context_sections else ""
-        
-        answer_prompt = f"""\no_think You are a general AI assistant. I will ask you a question. 
-        YOUR ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. 
-        If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. 
-        If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise.
-        If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string. 
-        Do not add a dot after the numbers.
-        Do not report on your thoughts. Do not provide explanations.
-{context_section}
-
-Question: {question}
-
-Answer:"""
-
-        try:
-            response = self._chat_completion(answer_prompt, max_tokens=500, temperature=0.3)
-            return response
-            
-        except Exception as e:
-            return f"Sorry, I encountered an error generating the response: {e}"
-
-    def _answer_with_search(self, question: str, attachment_context: str = "", url_context: str = "") -> str:
-        """
-        Generate answer using search results and LLM, considering attachment and URL context.
-        """
-        try:
-            # Perform search
-            time.sleep(10)
-            search_results = self.search(question)
-            
-            if not search_results:
-                return "No search results found. Let me try to answer based on my knowledge:\n\n" + self._answer_with_llm(question, attachment_context, url_context)
-
-            # Format search results - handle different result formats
-            if isinstance(search_results, str):
-                search_context = search_results
-            else:
-                # Handle list of results
-                formatted_results = []
-                for i, result in enumerate(search_results[:3]):  # Use top 3 results
-                    if isinstance(result, dict):
-                        title = result.get("title", "No title")
-                        snippet = result.get("snippet", "").strip()
-                        link = result.get("link", "")
-                        formatted_results.append(f"Title: {title}\nContent: {snippet}\nSource: {link}")
-                    elif isinstance(result, str):
-                        formatted_results.append(result)
-                    else:
-                        formatted_results.append(str(result))
-                
-                search_context = "\n\n".join(formatted_results)
-                
-
-            # Generate answer using search context, attachment context, and URL context
-            context_sections = [f"Search Results:\n{search_context}"]
-            
-            if attachment_context:
-                context_sections.append(f"Attachment Context:\n{attachment_context}")
-            
-            if url_context:
-                context_sections.append(f"URL Content:\n{url_context}")
-            
-            full_context = "\n\n".join(context_sections)
+        if self.debug and attachment_context:
+            print(f"Attachment context: {attachment_context[:200]}...")
 
+        # Decide whether to search
+        if self._should_search(question_text, attachment_context, url_context):
             if self.debug:
-               print(f"{full_context}")
-            
-            
-            answer_prompt = f"""\no_think You are a general AI assistant. I will ask you a question. 
-            Based on the search results and the context sections below, provide an answer to the question. 
-            If the search results don't fully answer the question, you can supplement with information from other context sections or your general knowledge. 
-            Your ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. 
-            Do not add dot if your answer is a number.
-            If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise.
-            If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. 
-            If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
-            Do not report on your thoughts. Do not provide explanations.
-
-Question: {question}
-
-{full_context}
-
-Answer:"""
-
-            try:
-                response = self._chat_completion(answer_prompt, max_tokens=600, temperature=0.3)
-                return response
-                
-            except Exception as e:
-                if self.debug:
-                    print(f"LLM generation error: {e}")
-                # Fallback to simple search result formatting
-                if search_results:
-                    if isinstance(search_results, str):
-                        return search_results
-                    elif isinstance(search_results, list) and len(search_results) > 0:
-                        first_result = search_results[0]
-                        if isinstance(first_result, dict):
-                            title = first_result.get("title", "Search Result")
-                            snippet = first_result.get("snippet", "").strip()
-                            link = first_result.get("link", "")
-                            return f"**{title}**\n\n{snippet}\n\n{f'Source: {link}' if link else ''}"
-                        else:
-                            return str(first_result)
-                    else:
-                        return str(search_results)
-                else:
-                    return "Search completed but no usable results found."
-
-        except Exception as e:
-            return f"Search failed: {e}. Let me try to answer based on my knowledge:\n\n" + self._answer_with_llm(question, attachment_context, url_context)
-
-    def process_question_with_attachments(self, question_data: dict) -> str:
-        """
-        Process a question that may have attachments and URLs.
-        """
-        question_text = question_data.get('question', '')          
-        print(question_data)
-        if self.debug:
-            print(f"\n1. Processing question with potential attachments and URLs: {question_text[:300]}...")
-
-        try:
-            # Detect and process URLs
-            print(f"2. Detecting and processing URLs...")
-            
-            url_context = self._extract_and_process_urls(question_text)
-            
+                print("5. Using search-based approach")
+            answer = self._answer_with_search(question_text, attachment_context, url_context)
+        else:
             if self.debug:
-                print(f"URL context: {url_context[:200]}...")
-        except Exception as e:
-            answer = f"Sorry, I encountered an error extracting URLs: {e}"
-            
-        try:    
-            # Detect and download attachments
-            print(f"3. Searching for images, audio or code attachments...")
-            attachment_name = question_data.get('file_name', '')
-            image_files, audio_files, code_files = self._detect_and_process_direct_attachments(attachment_name)
-            
-            # Process attachments to get context
-            attachment_context = self._process_attachments(image_files, audio_files, code_files)
-            
-            if self.debug and attachment_context:
-                print(f"Attachment context: {attachment_context[:200]}...")
-
-            # Decide whether to search
-            if self._should_search(question_text, attachment_context):
-                if self.debug:
-                    print("5. Using search-based approach")
-                answer = self._answer_with_search(question_text, attachment_context)
-            else:
-                if self.debug:
-                    print("5. Using LLM-only approach")
-                answer = self._answer_with_llm(question_text, attachment_context)
-                print("here")
-                print(answer)
-            # Cleanup temporary files
-            if image_files or audio_files or code_files:
-                try:
-                    all_files = image_files + audio_files + code_files
-                    temp_dirs = set(os.path.dirname(f) for f in all_files)
-                    for temp_dir in temp_dirs:
-                        import shutil
-                        shutil.rmtree(temp_dir, ignore_errors=True)
-                except Exception as cleanup_error:
-                    if self.debug:
-                        print(f"Cleanup error: {cleanup_error}")
+                print("5. Using LLM-only approach")
+            answer = self._answer_with_llm(question_text, attachment_context, url_context)
+            if self.debug:
+                print(f"LLM answer: {answer}")
 
-        except Exception as e:
-            answer = f"Sorry, I encountered an error: {e}"
+        # Note: We don't cleanup files here since they're not temporary files we created
+        # They are actual files in the working directory
 
+    except Exception as e:
         if self.debug:
-            print(f"6. Agent returning answer: {answer[:100]}...")
-        return answer
+            print(f"Error in attachment processing: {e}")
+        answer = f"Sorry, I encountered an error: {e}"
 
+    if self.debug:
+        print(f"6. Agent returning answer: {answer[:100]}...")
+    return answer
 def fetch_questions() -> Tuple[str, Optional[pd.DataFrame]]:
     """
     Fetch questions from the API and cache them.