Update app.py

app.py

@@ -1,16 +1,15 @@
 import os
+from dotenv import load_dotenv
 import gradio as gr
 import requests
 
-import os
-import requests
-import json
+import google.generativeai as genai
 from typing import List, Dict, Union
-from pydub import AudioSegment
+import requests
 import wikipediaapi
 import pandas as pd
-from PyPDF2 import PdfReader
-from docx import Document
+
+load_dotenv()
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -19,96 +18,34 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 class BasicAgent:
-    def __init__(self, ollama_base_url: str = "http://localhost:11434"):
-        self.ollama_url = f"{ollama_base_url}/api/generate"
-        self.searx_url = "https://searx.space/search"
+     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 (first 50 chars): {question[:50]}...")
-        fixed_answer = self.agent.run(question)
+        fixed_answer = self.agent.process_request(question)
         print(f"Agent returning answer: {fixed_answer}")
         return fixed_answer
 
-        # Initialize Vosk if available
-        self.vosk_model = None
-        try:
-            from vosk import Model, KaldiRecognizer
-            model_path = "vosk-model-small-en-us-0.15"
-            if os.path.exists(model_path):
-                self.vosk_model = Model(model_path)
-        except ImportError:
-            pass
-
-    def transcribe_audio(self, audio_path: str) -> str:
-        """Speech-to-text using Vosk or basic audio processing"""
-        # Convert to WAV if needed
-        if not audio_path.endswith('.wav'):
-            try:
-                sound = AudioSegment.from_file(audio_path)
-                audio_path = "temp.wav"
-                sound.export(audio_path, format="wav")
-            except:
-                return "Audio conversion failed"
-
-        # Try Vosk first if available
-        if self.vosk_model:
-            try:
-                from vosk import KaldiRecognizer
-                import wave
-                wf = wave.open(audio_path, "rb")
-                rec = KaldiRecognizer(self.vosk_model, wf.getframerate())
-                
-                results = []
-                while True:
-                    data = wf.readframes(4000)
-                    if len(data) == 0:
-                        break
-                    if rec.AcceptWaveform(data):
-                        results.append(json.loads(rec.Result()))
-                
-                final = json.loads(rec.FinalResult())
-                if final['text']:
-                    results.append(final)
-                return " ".join([r['text'] for r in results if 'text' in r])
-            except Exception as e:
-                return f"Vosk Error: {str(e)}"
-        
-        # Fallback: Return audio metadata
-        try:
-            sound = AudioSegment.from_file(audio_path)
-            return f"Audio file: {sound.duration_seconds} seconds, {sound.channels} channels"
-        except:
-            return "Audio processing failed"
 
-    def transcribe_audio(self, audio_path: str) -> str:
-        """Speech-to-text using Vosk or basic audio processing"""
-        # Convert to WAV if needed
-        if not audio_path.endswith('.wav'):
-            try:
-                sound = AudioSegment.from_file(audio_path)
-                audio_path = "temp.wav"
-                sound.export(audio_path, format="wav")
-            except:
-                return "Audio conversion failed"
 
- 
-        
-    def call_llm(self, prompt: str, model: str = "llama3") -> str:
-        """Call local Ollama LLM"""
-        payload = {
-            "model": model,
-            "prompt": prompt,
-            "stream": False
-        }
+    def generate_response(self, prompt: str) -> str:
+        """Get response from Gemini"""
         try:
-            response = requests.post(self.ollama_url, json=payload)
-            response.raise_for_status()
-            return response.json().get("response", "")
-        except requests.RequestException as e:
-            return f"LLM Error: {str(e)}"
+            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"""
@@ -138,12 +75,9 @@ class BasicAgent:
         
         try:
             if ext == '.pdf':
-                with open(file_path, 'rb') as f:
-                    reader = PdfReader(f)
-                    return "\n".join([page.extract_text() for page in reader.pages])
+                return self._process_pdf(file_path)
             elif ext in ('.doc', '.docx'):
-                doc = Document(file_path)
-                return "\n".join([para.text for para in doc.paragraphs])
+                return self._process_word(file_path)
             elif ext == '.csv':
                 return pd.read_csv(file_path).to_string()
             elif ext in ('.xls', '.xlsx'):
@@ -153,20 +87,34 @@ class BasicAgent:
         except Exception as e:
             return f"Error processing document: {str(e)}"
 
-    def transcribe_audio(self, audio_path: str) -> str:
-        """Convert speech to text using Vosk (offline)"""
+    def _process_pdf(self, file_path: str) -> str:
+        """Process PDF using Gemini's vision capability"""
         try:
-            # Convert to WAV if needed
-            if not audio_path.endswith('.wav'):
-                sound = AudioSegment.from_file(audio_path)
-                audio_path = "temp.wav"
-                sound.export(audio_path, format="wav")
-            
-            with sr.AudioFile(audio_path) as source:
-                audio = self.recognizer.record(source)
-                return self.recognizer.recognize_vosk(audio)
-        except Exception as e:
-            return f"Transcription failed: {str(e)}"
+            # 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:
         """
@@ -176,7 +124,6 @@ class BasicAgent:
         - Complex multi-step requests
         """
         if isinstance(request, dict):
-            # Complex request handling
             if 'steps' in request:
                 results = []
                 for step in request['steps']:
@@ -184,11 +131,11 @@ class BasicAgent:
                         results.append(self.web_search(step['query']))
                     elif step['type'] == 'process':
                         results.append(self.process_document(step['file']))
-                return self.call_llm(f"Process these results: {json.dumps(results)}")
+                return self.generate_response(f"Process these results: {results}")
             return "Unsupported request format"
         
-        # Simple text query
-        return self.call_llm(request)
+        return self.generate_response(request)
+