Update app.py

app.py

@@ -1,146 +1,36 @@
 
-from dotenv import load_dotenv
+import os
+import inspect
 import gradio as gr
 import requests
-
-from typing import List, Dict, Union, Optional
 import pandas as pd
-import wikipediaapi
-import requests
-#from bs4 import BeautifulSoup
-import random
-import re
-from typing import Optional
-from datetime import datetime
-import google.generativeai as genai
+from langchain_core.messages import HumanMessage
+from agent import build_graph
+
 
-load_dotenv()
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-
 # --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+
 
 class BasicAgent:
-     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
-        
+    """A langgraph agent."""
+    def __init__(self):
         print("BasicAgent initialized.")
+        self.graph = build_graph()
 
-     def __call__(self, question: str) -> str:
+    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)}"
+        # Wrap the question in a HumanMessage from langchain_core
+        messages = [HumanMessage(content=question)]
+        messages = self.graph.invoke({"messages": messages})
+        answer = messages['messages'][-1].content
+        return answer[14:]
 
-     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 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:
-            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"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)
 
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):