Update app.py

app.py

@@ -7,11 +7,12 @@ from typing import List, Dict, Union, Optional
 import pandas as pd
 import wikipediaapi
 import requests
-from bs4 import BeautifulSoup
+#from bs4 import BeautifulSoup
 import random
 import re
 from typing import Optional
 from datetime import datetime
+import google.generativeai as genai
 
 load_dotenv()
 
@@ -22,65 +23,125 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 
-import requests
-from bs4 import BeautifulSoup
-
 class BasicAgent:
-    def __init__(self):
+     def __init__(self, model_name: str = "gemini-pro"):
+        """
+        Multi-modal agent powered by Google Gemini with:
+        - Web search
+        - Wikipedia access
+        - Document processing
+        """
+        self.model = genai.GenerativeModel(model_name)
+        self.wiki = wikipediaapi.Wikipedia('en')
+        self.searx_url = "https://searx.space/search"  # Public Searx instance
+        
         print("BasicAgent initialized.")
 
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question: {question[:50]}...")
-        answer = self.basic_search(question)
-        print(f"Answer: {answer[:200]}...")  # Truncate long answers
-        return answer
+     def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        fixed_answer = self.process_request(question)
+        print(f"Agent returning answer: {fixed_answer}")
+        return fixed_answer
+
+
+
+     def generate_response(self, prompt: str) -> str:
+        """Get response from Gemini"""
+        try:
+            response = self.model.generate_content(prompt)
+            return response.text
+        except Exception as e:
+            return f"Error generating response: {str(e)}"
+
+     def web_search(self, query: str) -> List[Dict]:
+        """Use SearxNG meta-search engine"""
+        params = {
+            "q": query,
+            "format": "json",
+            "engines": "google,bing,duckduckgo"
+        }
+        try:
+            response = requests.get(self.searx_url, params=params)
+            response.raise_for_status()
+            return response.json().get("results", [])
+        except requests.RequestException:
+            return []
+
+     def wikipedia_search(self, query: str) -> str:
+        """Get Wikipedia summary"""
+        page = self.wiki.page(query)
+        return page.summary if page.exists() else "No Wikipedia page found"
 
-    def basic_search(self, query):
+     def process_document(self, file_path: str) -> str:
+        """Handle PDF, Word, CSV, Excel files"""
+        if not os.path.exists(file_path):
+            return "File not found"
+        
+        ext = os.path.splitext(file_path)[1].lower()
+        
         try:
-            # DuckDuckGo search URL
-            url = "https://html.duckduckgo.com/html/"
-            
-            # Headers to mimic a browser request
-            headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; rv:91.0) Gecko/20100101 Firefox/91.0',
-                'Accept': 'text/html,application/xhtml+xml',
-                'Accept-Language': 'en-US,en;q=0.5',
-            }
-            
-            # Search parameters
-            params = {
-                'q': query,
-                'kl': 'us-en'
-            }
-            
-            # Make the POST request
-            response = requests.post(url, headers=headers, data=params)
-            response.raise_for_status()  # Raise exception for bad status codes
-            
-            # Parse the HTML response
-            soup = BeautifulSoup(response.text, 'html.parser')
-            
-            # Find all search results
-            results = soup.find_all('div', class_='result')
-            
-            if not results:
-                return "No results found for your query."
-                
-            # Prepare the answer with top 3 results
-            answer = "Here are the top search results:\n\n"
-            for i, result in enumerate(results[:3], 1):  # Limit to 3 results
-                title = result.find('a', class_='result__a').get_text(strip=True)
-                link = result.find('a', class_='result__a')['href']
-                snippet = result.find('a', class_='result__snippet').get_text(strip=True) if result.find('a', class_='result__snippet') else "No description available"
-                
-                answer += f"{i}. {title}\n   URL: {link}\n   Description: {snippet}\n\n"
-            
-            return answer
-            
-        except requests.exceptions.RequestException as e:
-            return f"Failed to complete the search request: {str(e)}"
+            if ext == '.pdf':
+                return self._process_pdf(file_path)
+            elif ext in ('.doc', '.docx'):
+                return self._process_word(file_path)
+            elif ext == '.csv':
+                return pd.read_csv(file_path).to_string()
+            elif ext in ('.xls', '.xlsx'):
+                return pd.read_excel(file_path).to_string()
+            else:
+                return "Unsupported file format"
         except Exception as e:
-            return f"An unexpected error occurred: {str(e)}"
+            return f"Error processing document: {str(e)}"
+
+     def _process_pdf(self, file_path: str) -> str:
+        """Process PDF using Gemini's vision capability"""
+        try:
+            # For Gemini 1.5 or later which supports file uploads
+            with open(file_path, "rb") as f:
+                file = genai.upload_file(f)
+                response = self.model.generate_content(
+                    ["Extract and summarize the key points from this document:", file]
+                )
+                return response.text
+        except:
+            # Fallback for older Gemini versions
+            try:
+                import PyPDF2
+                with open(file_path, 'rb') as f:
+                    reader = PyPDF2.PdfReader(f)
+                    return "\n".join([page.extract_text() for page in reader.pages])
+            except ImportError:
+                return "PDF processing requires PyPDF2 (pip install PyPDF2)"
+
+     def _process_word(self, file_path: str) -> str:
+        """Process Word documents"""
+        try:
+            from docx import Document
+            doc = Document(file_path)
+            return "\n".join([para.text for para in doc.paragraphs])
+        except ImportError:
+            return "Word processing requires python-docx (pip install python-docx)"
+
+     def process_request(self, request: Union[str, Dict]) -> str:
+        """
+        Handle different request types:
+        - Direct text queries
+        - File processing requests
+        - Complex multi-step requests
+        """
+        if isinstance(request, dict):
+            if 'steps' in request:
+                results = []
+                for step in request['steps']:
+                    if step['type'] == 'search':
+                        results.append(self.web_search(step['query']))
+                    elif step['type'] == 'process':
+                        results.append(self.process_document(step['file']))
+                return self.generate_response(f"Process these results: {results}")
+            return "Unsupported request format"
+        
+        return self.generate_response(request)
+