new version

app.py

@@ -1,126 +1,879 @@
-from huggingface_hub import snapshot_download
-
-# Download models from Hugging Face to local folders
-snapshot_download(
-    repo_id="OpenVINO/Mistral-7B-Instruct-v0.2-int4-ov",
-    local_dir="mistral-ov"
-)
-snapshot_download(
-    repo_id="OpenVINO/whisper-tiny-fp16-ov",
-    local_dir="whisper-ov-model"
-)
-
-import gradio as gr
-import openvino_genai
-import librosa
-import numpy as np
-from threading import Thread, Lock, Event
-from scipy.ndimage import uniform_filter1d
-from queue import Queue, Empty
-
-# Initialize Mistral pipeline
-mistral_pipe = openvino_genai.LLMPipeline("mistral-ov", device="CPU")
-config = openvino_genai.GenerationConfig(
-    max_new_tokens=100,
-    num_beams=1,
-    do_sample=False,
-    temperature=0.0,
-    top_p=1.0,
-    top_k=50  
-)
-pipe_lock = Lock()
-
-# Initialize Whisper pipeline 
-whisper_pipe = openvino_genai.WhisperPipeline("whisper-ov-model", device="CPU")
-
-def process_audio(data, sr):
-    """Audio processing with silence trimming"""
-    data = librosa.to_mono(data.T) if data.ndim > 1 else data
-    data = data.astype(np.float32)
-    data /= np.max(np.abs(data))
-    
-    # Voice activity detection
-    frame_length, hop_length = 2048, 512
-    rms = librosa.feature.rms(y=data, frame_length=frame_length, hop_length=hop_length)[0]
-    smoothed_rms = uniform_filter1d(rms, size=5)
-    speech_frames = np.where(smoothed_rms > 0.025)[0]
-    
-    if not speech_frames.size:
-        return None
-    
-    start = max(0, int(speech_frames[0] * hop_length - 0.1*sr))
-    end = min(len(data), int((speech_frames[-1]+1) * hop_length + 0.1*sr))
-    return data[start:end]
-
-def transcribe(audio):
-    """Audio to text transcription"""
-    sr, data = audio
-    processed = process_audio(data, sr)
-    if processed is None or len(processed) < 1600:
-        return ""
-    
-    if sr != 16000:
-        processed = librosa.resample(processed, orig_sr=sr, target_sr=16000)
-    
-    return whisper_pipe.generate(processed)
-
-def stream_generator(message, history):
-    response_queue = Queue()
-    completion_event = Event()
-    error_message = [None]
-
-    def callback(token):
-        response_queue.put(token)
-        return openvino_genai.StreamingStatus.RUNNING
-
-    def generate():
-        try:
-            with pipe_lock:
-                mistral_pipe.generate(message, config, callback)
-        except Exception as e:
-            error_message[0] = str(e)
-        finally:
-            completion_event.set()
-
-    Thread(target=generate, daemon=True).start()
-
-    accumulated = []
-    while not completion_event.is_set() or not response_queue.empty():
-        if error_message[0]:
-            yield f"Error: {error_message[0]}"
-            return
-
-        try:
-            token = response_queue.get_nowait()
-            accumulated.append(token)
-            yield "".join(accumulated)
-        except Empty:
-            continue
-
-    yield "".join(accumulated)
-
-with gr.Blocks() as demo:
-    chat_interface = gr.ChatInterface(
-        stream_generator,
-        textbox=gr.Textbox(placeholder="Ask Mistral...", container=False),
-        title="EDU CHAT BY PHANINDRA REDDY K",
-        examples=[
-            "Explain quantum physics simply",
-            "Write a haiku about technology",
-            "What's the meaning of life?"
-        ],
-        cache_examples=False,
-    )
-    
-    with gr.Row():
-        audio = gr.Audio(sources=["microphone"], type="numpy", label="Voice Input")
-        transcribe_btn = gr.Button("Send Transcription")
-    
-    transcribe_btn.click(
-        transcribe,
-        inputs=audio,
-        outputs=chat_interface.textbox
-    )
-
-if __name__ == "__main__":
-    demo.launch(share=True,debug=True)
+import time
+import gradio as gr
+import pandas as pd
+import openvino_genai
+from huggingface_hub import snapshot_download
+from threading import Lock
+import os
+import numpy as np
+import requests
+from PIL import Image
+from io import BytesIO
+import cpuinfo
+import openvino as ov
+import librosa
+from googleapiclient.discovery import build
+import gc
+import tempfile
+from PyPDF2 import PdfReader
+from docx import Document
+import textwrap
+
+# Google API configuration
+GOOGLE_API_KEY = "AIzaSyAo-1iW5MEZbc53DlEldtnUnDaYuTHUDH4"
+GOOGLE_CSE_ID = "3027bedf3c88a4efb"
+DEFAULT_MAX_TOKENS = 100
+DEFAULT_NUM_IMAGES = 1
+MAX_HISTORY_TURNS = 3
+MAX_TOKENS_LIMIT = 1000
+
+class UnifiedAISystem:
+    def __init__(self):
+        self.pipe_lock = Lock()
+        self.current_df = None
+        self.mistral_pipe = None
+        self.internvl_pipe = None
+        self.whisper_pipe = None
+        self.current_document_text = None  # Store document content
+        self.initialize_models()
+
+    def initialize_models(self):
+        """Initialize all required models"""
+        # Download models if not exists
+        if not os.path.exists("mistral-ov"):
+            snapshot_download(repo_id="OpenVINO/mistral-7b-instruct-v0.1-int8-ov", local_dir="mistral-ov")
+        if not os.path.exists("internvl-ov"):
+            snapshot_download(repo_id="OpenVINO/InternVL2-1B-int8-ov", local_dir="internvl-ov")
+        if not os.path.exists("whisper-ov-model"):
+            snapshot_download(repo_id="OpenVINO/whisper-tiny-fp16-ov", local_dir="whisper-ov-model")
+
+        # CPU-specific configuration
+        cpu_features = cpuinfo.get_cpu_info()['flags']
+        config_options = {}
+        if 'avx512' in cpu_features:
+            config_options["ENFORCE_BF16"] = "YES"
+        elif 'avx2' in cpu_features:
+            config_options["INFERENCE_PRECISION_HINT"] = "f32"
+
+        # Initialize Mistral model
+        self.mistral_pipe = openvino_genai.LLMPipeline(
+            "mistral-ov",
+            device="CPU",
+            config={"PERFORMANCE_HINT": "THROUGHPUT", **config_options}
+        )
+
+        # Initialize Whisper for audio processing
+        self.whisper_pipe = openvino_genai.WhisperPipeline("whisper-ov-model", device="CPU")
+
+    def load_data(self, file_path):
+        """Load student data from file"""
+        try:
+            file_ext = os.path.splitext(file_path)[1].lower()
+            if file_ext == '.csv':
+                self.current_df = pd.read_csv(file_path)
+            elif file_ext in ['.xlsx', '.xls']:
+                self.current_df = pd.read_excel(file_path)
+            else:
+                return False, "❌ Unsupported file format. Please upload a .csv or .xlsx file."
+            return True, f"✅ Loaded {len(self.current_df)} records from {os.path.basename(file_path)}"
+        except Exception as e:
+            return False, f"❌ Error loading file: {str(e)}"
+
+    def extract_text_from_document(self, file_path):
+        """Extract text from PDF or DOCX documents"""
+        text = ""
+        try:
+            file_ext = os.path.splitext(file_path)[1].lower()
+
+            if file_ext == '.pdf':
+                with open(file_path, 'rb') as file:
+                    pdf_reader = PdfReader(file)
+                    for page in pdf_reader.pages:
+                        text += page.extract_text() + "\n"
+
+            elif file_ext == '.docx':
+                doc = Document(file_path)
+                for para in doc.paragraphs:
+                    text += para.text + "\n"
+
+            else:
+                return False, "❌ Unsupported document format. Please upload PDF or DOCX."
+
+            # Clean and format text
+            text = text.replace('\x0c', '')  # Remove form feed characters
+            text = textwrap.dedent(text)      # Remove common leading whitespace
+            self.current_document_text = text
+            return True, f"✅ Extracted text from {os.path.basename(file_path)}"
+
+        except Exception as e:
+            return False, f"❌ Error processing document: {str(e)}"
+
+    def analyze_student_data(self, query):
+        """Analyze student data using AI with streaming"""
+        if not query or not query.strip():
+            yield "⚠️ Please enter a valid question"
+            return
+
+        if self.current_df is None:
+            yield "⚠️ Please upload and load a student data file first"
+            return
+
+        data_summary = self._prepare_data_summary(self.current_df)
+        prompt = f"""You are an expert education analyst. Analyze the following student performance data:
+        {data_summary}
+
+        Question: {query}
+
+        Please include:
+        1. Direct answer to the question
+        2. Relevant statistics
+        3. Key insights
+        4. Actionable recommendations
+
+        Format the output with clear headings"""
+
+        optimized_config = openvino_genai.GenerationConfig(
+            max_new_tokens=500,
+            temperature=0.3,
+            top_p=0.9,
+            streaming=True
+        )
+
+        full_response = ""
+        try:
+            with self.pipe_lock:
+                token_iterator = self.mistral_pipe.generate(prompt, optimized_config, streaming=True)
+                for token in token_iterator:
+                    full_response += token
+                    yield full_response
+        except Exception as e:
+            yield f"❌ Error during analysis: {str(e)}"
+
+    def _prepare_data_summary(self, df):
+        """Summarize the uploaded data"""
+        summary = f"Student performance data with {len(df)} rows and {len(df.columns)} columns.\n"
+        summary += "Columns: " + ", ".join(df.columns) + "\n"
+        summary += "First 3 rows:\n" + df.head(3).to_string(index=False)
+        return summary
+
+    def analyze_image(self, image, url, prompt):
+        """Analyze image with InternVL model"""
+        try:
+            if image is not None:
+                image_source = image
+            elif url and url.startswith(("http://", "https://")):
+                response = requests.get(url)
+                image_source = Image.open(BytesIO(response.content)).convert("RGB")
+            else:
+                return "⚠️ Please upload an image or enter a valid URL"
+
+            # Convert to OpenVINO tensor
+            image_data = np.array(image_source.getdata()).reshape(
+                1, image_source.size[1], image_source.size[0], 3
+            ).astype(np.byte)
+            image_tensor = ov.Tensor(image_data)
+
+            # Lazy initialize InternVL
+            if self.internvl_pipe is None:
+                self.internvl_pipe = openvino_genai.VLMPipeline("internvl-ov", device="CPU")
+
+            with self.pipe_lock:
+                self.internvl_pipe.start_chat()
+                output = self.internvl_pipe.generate(prompt, image=image_tensor, max_new_tokens=100)
+                self.internvl_pipe.finish_chat()
+
+            return output
+        except Exception as e:
+            return f"❌ Error: {str(e)}"
+
+    def process_audio(self, data, sr):
+        """Process audio data for speech recognition"""
+        try:
+            # Convert to mono
+            if data.ndim > 1:
+                data = np.mean(data, axis=1)  # Simple mono conversion
+            else:
+                data = data
+
+            # Convert to float32 and normalize
+            data = data.astype(np.float32)
+            max_val = np.max(np.abs(data)) + 1e-7
+            data /= max_val
+
+            # Simple noise reduction
+            data = np.clip(data, -0.5, 0.5)
+
+            # Trim silence
+            energy = np.abs(data)
+            threshold = np.percentile(energy, 25)  # Simple threshold
+            mask = energy > threshold
+            indices = np.where(mask)[0]
+
+            if len(indices) > 0:
+                start = max(0, indices[0] - 1000)
+                end = min(len(data), indices[-1] + 1000)
+                data = data[start:end]
+
+            # Resample if needed using simpler method
+            if sr != 16000:
+                # Calculate new length
+                new_length = int(len(data) * 16000 / sr)
+                # Linear interpolation for resampling
+                data = np.interp(
+                    np.linspace(0, len(data)-1, new_length),
+                    np.arange(len(data)),
+                    data
+                )
+                sr = 16000
+
+            return data
+        except Exception as e:
+            print(f"Audio processing error: {e}")
+            return np.array([], dtype=np.float32)
+
+    def transcribe(self, audio):
+        """Transcribe audio using Whisper model with improved error handling"""
+        if audio is None:
+            return ""
+        sr, data = audio
+
+        # Skip if audio is too short (less than 0.5 seconds)
+        if len(data)/sr < 0.5:
+            return ""
+
+        try:
+            processed = self.process_audio(data, sr)
+
+            # Skip if audio is still too short after processing
+            if len(processed) < 8000:  # 0.5 seconds at 16kHz
+                return ""
+
+            # Use OpenVINO Whisper pipeline
+            result = self.whisper_pipe.generate(processed)
+            return result
+        except Exception as e:
+            print(f"Transcription error: {e}")
+            return "❌ Transcription failed - please try again"
+
+    def generate_lesson_plan(self, topic, duration, additional_instructions=""):
+        """Generate a lesson plan based on document content"""
+        if not self.current_document_text:
+            return "⚠️ Please upload and process a document first"
+
+        prompt = f"""As an expert educator, create a focused lesson plan using the provided content.
+
+        **Core Requirements:**
+        1. TOPIC: {topic}
+        2. TOTAL DURATION: {duration} periods
+        3. ADDITIONAL INSTRUCTIONS: {additional_instructions or 'None'}
+
+        **Content Summary:**
+        {self.current_document_text[:2500]}... [truncated]
+
+        **Output Structure:**
+        1. PERIOD ALLOCATION (Break topic into {duration} logical segments):
+          - Period 1: [Subtopic 1]
+          - Period 2: [Subtopic 2]
+             ...
+
+        2. LEARNING OBJECTIVES (Max 3 bullet points)
+        3. TEACHING ACTIVITIES (One engaging method per period)
+        4. RESOURCES (Key materials from document)
+        5. ASSESSMENT (Simple checks for understanding)
+        6. PAGE REFERENCES (Specific source pages)
+
+**Key Rules:**
+- Strictly divide content into exactly {duration} periods
+- Prioritize document content over creativity
+- Keep objectives measurable
+- Use only document resources
+- Make page references specific"""
+
+
+        optimized_config = openvino_genai.GenerationConfig(
+            max_new_tokens=1200,
+            temperature=0.4,
+            top_p=0.85
+        )
+
+        try:
+            with self.pipe_lock:
+                return self.mistral_pipe.generate(prompt, optimized_config)
+        except Exception as e:
+            return f"❌ Error generating lesson plan: {str(e)}"
+
+    def fetch_images(self, query: str, num: int = DEFAULT_NUM_IMAGES) -> list:
+        """Fetch unique images by requesting different result pages"""
+        if num <= 0:
+            return []
+
+        try:
+            service = build("customsearch", "v1", developerKey=GOOGLE_API_KEY)
+            image_links = []
+            seen_urls = set()  # To track unique URLs
+
+            # Start from different positions to get unique images
+            for start_index in range(1, num * 2, 2):
+                if len(image_links) >= num:
+                    break
+
+                res = service.cse().list(
+                    q=query,
+                    cx=GOOGLE_CSE_ID,
+                    searchType="image",
+                    num=1,
+                    start=start_index
+                ).execute()
+
+                if "items" in res and res["items"]:
+                    item = res["items"][0]
+                    # Skip duplicates
+                    if item["link"] not in seen_urls:
+                        image_links.append(item["link"])
+                        seen_urls.add(item["link"])
+
+            return image_links[:num]
+        except Exception as e:
+            print(f"Error in image fetching: {e}")
+            return []
+
+    def stream_answer(self, message: str, max_tokens: int) -> str:
+        """Stream tokens with typing indicator"""
+        optimized_config = openvino_genai.GenerationConfig(
+            max_new_tokens=max_tokens,
+            temperature=0.7,
+            top_p=0.9,
+            streaming=True
+        )
+
+        full_response = ""
+        try:
+            with self.pipe_lock:
+                token_iterator = self.mistral_pipe.generate(message, optimized_config, streaming=True)
+                for token in token_iterator:
+                    full_response += token
+                    yield full_response
+                    # Periodic garbage collection
+                    if len(full_response) % 20 == 0:
+                        gc.collect()
+        except Exception as e:
+            yield f"❌ Error: {str(e)}"
+
+# Initialize global object
+ai_system = UnifiedAISystem()
+
+# CSS styles with improved output box
+css = """
+    .gradio-container {
+        background-color: #121212;
+        color: #fff;
+    }
+    .user-msg, .bot-msg {
+        padding: 12px 16px;
+        border-radius: 18px;
+        margin: 8px 0;
+        line-height: 1.5;
+        border: none;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .user-msg {
+        background: linear-gradient(135deg, #4a5568, #2d3748);
+        color: white;
+        margin-left: 20%;
+        border-bottom-right-radius: 5px;
+        border: none;
+    }
+    .bot-msg {
+        background: linear-gradient(135deg, #2d3748, #1a202c);
+        color: white;
+        margin-right: 20%;
+        border-bottom-left-radius: 5px;
+        border: none;
+    }
+    /* Remove top border from chat messages */
+    .user-msg, .bot-msg {
+        border-top: none !important;
+    }
+    /* Remove borders from chat container */
+    .chatbot > div {
+        border: none !important;
+    }
+    .chatbot .message {
+        border: none !important;
+    }
+    /* Improve scrollbar */
+    .chatbot::-webkit-scrollbar {
+        width: 8px;
+    }
+    .chatbot::-webkit-scrollbar-track {
+        background: #2a2a2a;
+        border-radius: 4px;
+    }
+    .chatbot::-webkit-scrollbar-thumb {
+        background: #4a5568;
+        border-radius: 4px;
+    }
+    .chatbot::-webkit-scrollbar-thumb:hover {
+        background: #5a6578;
+    }
+    /* Rest of the CSS remains the same */
+    .gradio-container {
+        background-color: #121212;
+        color: #fff;
+    }
+    .upload-box {
+        background-color: #333;
+        border-radius: 8px;
+        padding: 16px;
+        margin-bottom: 16px;
+    }
+    #question-input {
+        background-color: #333;
+        color: #fff;
+        border-radius: 8px;
+        padding: 12px;
+        border: 1px solid #555;
+    }
+    .mode-checkbox {
+        background-color: #333;
+        color: #fff;
+        border: 1px solid #555;
+        border-radius: 8px;
+        padding: 10px;
+        margin: 5px;
+    }
+    .slider-container {
+        margin-top: 20px;
+        padding: 15px;
+        border-radius: 10px;
+        background-color: #2a2a2a;
+    }
+    .system-info {
+        background-color: #7B9BDB;
+        padding: 15px;
+        border-radius: 8px;
+        margin: 15px 0;
+        border-left: 4px solid #1890ff;
+    }
+    .chat-image {
+        cursor: pointer;
+        transition: transform 0.2s;
+        max-height: 100px;
+        margin: 4px;
+        border-radius: 8px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    .chat-image:hover {
+        transform: scale(1.05);
+        box-shadow: 0 4px 8px rgba(0,0,0,0.2);
+    }
+    .modal {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0,0,0,0.8);
+        display: none;
+        z-index: 1000;
+        cursor: zoom-out;
+    }
+    .modal-content {
+        position: absolute;
+        top: 50%;
+        left: 50%;
+        transform: translate(-50%, -50%);
+        max-width: 90%;
+        max-height: 90%;
+        background: white;
+        padding: 10px;
+        border-radius: 12px;
+    }
+    .modal-img {
+        width: auto;
+        height: auto;
+        max-width: 100%;
+        max-height: 100%;
+        border-radius: 8px;
+    }
+    .typing-indicator {
+        display: inline-block;
+        position: relative;
+        width: 40px;
+        height: 20px;
+    }
+    .typing-dot {
+        display: inline-block;
+        width: 6px;
+        height: 6px;
+        border-radius: 50%;
+        background-color: #fff;
+        position: absolute;
+        animation: typing 1.4s infinite ease-in-out;
+    }
+    .typing-dot:nth-child(1) {
+        left: 0;
+        animation-delay: 0s;
+    }
+    .typing-dot:nth-child(2) {
+        left: 12px;
+        animation-delay: 0.2s;
+    }
+    .typing-dot:nth-child(3) {
+        left: 24px;
+        animation-delay: 0.4s;
+    }
+    @keyframes typing {
+        0%, 60%, 100% { transform: translateY(0); }
+        30% { transform: translateY(-5px); }
+    }
+    .lesson-plan {
+        background: linear-gradient(135deg, #1a202c, #2d3748);
+        padding: 15px;
+        border-radius: 12px;
+        margin: 10px 0;
+        border-left: 4px solid #4a9df0;
+    }
+    .lesson-section {
+        margin-bottom: 15px;
+        padding-bottom: 10px;
+        border-bottom: 1px solid #4a5568;
+    }
+    .lesson-title {
+        font-size: 1.2em;
+        font-weight: bold;
+        color: #4a9df0;
+        margin-bottom: 8px;
+    }
+    .page-ref {
+        background-color: #4a5568;
+        padding: 3px 8px;
+        border-radius: 4px;
+        font-size: 0.9em;
+        display: inline-block;
+        margin: 3px;
+    }
+"""
+
+# Create Gradio interface
+with gr.Blocks(css=css, title="Unified EDU Assistant") as demo:
+    gr.Markdown("# 🤖 Unified EDU Assistant by Phanindra Reddy K")
+
+    # System info banner
+    gr.HTML("""
+    <div class="system-info">
+        <strong>Multi-Modal AI Assistant</strong>
+        <ul>
+            <li>Text & Voice Chat with Mistral-7B</li>
+            <li>Image Understanding with InternVL</li>
+            <li>Student Data Analysis</li>
+            <li>Visual Search with Google Images</li>
+            <li>Lesson Planning from Documents</li>
+        </ul>
+    </div>
+    """)
+
+    # Modal for image preview
+    modal_html = """
+    <div class="modal" id="imageModal" onclick="this.style.display='none'">
+        <div class="modal-content">
+            <img class="modal-img" id="expandedImg">
+        </div>
+    </div>
+    <script>
+    function showImage(url) {
+        document.getElementById('expandedImg').src = url;
+        document.getElementById('imageModal').style.display = 'block';
+    }
+    </script>
+    """
+    gr.HTML(modal_html)
+
+    chat_state = gr.State([])
+    with gr.Column(scale=2, elem_classes="chat-container"):
+        chatbot = gr.Chatbot(label="Conversation", height=500, bubble_full_width=False,
+                            avatar_images=("user.png", "bot.png"), show_label=False)
+
+    # Mode selection
+    with gr.Row():
+        chat_mode = gr.Checkbox(label="💬 General Chat", value=True, elem_classes="mode-checkbox")
+        student_mode = gr.Checkbox(label="🎓 Student Analytics", value=False, elem_classes="mode-checkbox")
+        image_mode = gr.Checkbox(label="🖼️ Image Analysis", value=False, elem_classes="mode-checkbox")
+        lesson_mode = gr.Checkbox(label="📝 Lesson Planning", value=False, elem_classes="mode-checkbox")
+
+    # Dynamic input fields
+    with gr.Column() as chat_inputs:
+        include_images = gr.Checkbox(label="Include Visuals", value=True)
+        user_input = gr.Textbox(
+            placeholder="Type your question here...",
+            label="Your Question",
+            container=False,
+            elem_id="question-input"
+        )
+        with gr.Row():
+            max_tokens = gr.Slider(
+                minimum=10,
+                maximum=1000,
+                value=100,
+                step=10,
+                label="Response Length (Tokens)"
+            )
+            num_images = gr.Slider(
+                minimum=0,
+                maximum=5,
+                value=1,
+                step=1,
+                label="Number of Images",
+                visible=True
+            )
+
+    with gr.Column(visible=False) as student_inputs:
+        file_upload = gr.File(label="CSV/Excel File", file_types=[".csv", ".xlsx"], type="filepath")
+        student_question = gr.Textbox(
+            placeholder="Ask questions about student data...",
+            label="Your Question",
+            elem_id="question-input"
+        )
+        student_status = gr.Markdown("No file loaded")
+
+    with gr.Column(visible=False) as image_inputs:
+        image_upload = gr.Image(type="pil", label="Upload Image")
+        image_url = gr.Textbox(
+            label="OR Enter Image URL",
+            placeholder="https://example.com/image.jpg",
+            elem_id="question-input"
+        )
+        image_question = gr.Textbox(
+            placeholder="Ask questions about the image...",
+            label="Your Question",
+            elem_id="question-input"
+        )
+
+    # Lesson planning section
+    with gr.Column(visible=False) as lesson_inputs:
+        gr.Markdown("### 📚 Lesson Planning")
+        doc_upload = gr.File(
+            label="Upload Curriculum Document (PDF/DOCX)",
+            file_types=[".pdf", ".docx"],
+            type="filepath"
+        )
+        doc_status = gr.Markdown("No document uploaded")
+
+        with gr.Row():
+            topic_input = gr.Textbox(
+                label="Lesson Topic",
+                placeholder="Enter the main topic for the lesson plan"
+            )
+            duration_input = gr.Number(
+                label="Total Periods",
+                value=5,
+                minimum=1,
+                maximum=20,
+                step=1
+            )
+
+        additional_instructions = gr.Textbox(
+            label="Additional Requirements (optional)",
+            placeholder="Specific teaching methods, resources, or special considerations..."
+        )
+
+        generate_btn = gr.Button("Generate Lesson Plan", variant="primary")
+
+    # Common controls
+    with gr.Row():
+        submit_btn = gr.Button("Send", variant="primary")
+        mic_btn = gr.Button("Transcribe Voice", variant="secondary")
+        mic = gr.Audio(sources=["microphone"], type="numpy", label="Voice Input")
+
+    processing = gr.HTML("""
+        <div style="display: none;">
+            <div class="processing">🔮 Processing your request...</div>
+        </div>
+    """)
+
+    # Event handlers
+    def toggle_modes(chat, student, image, lesson):
+        return [
+            gr.update(visible=chat),
+            gr.update(visible=student),
+            gr.update(visible=image),
+            gr.update(visible=lesson)
+        ]
+
+    def load_student_file(file_path):
+        success, message = ai_system.load_data(file_path)
+        return message
+
+    def process_document(file_path):
+        if not file_path:
+            return "⚠️ Please select a document first"
+        success, message = ai_system.extract_text_from_document(file_path)
+        return message
+
+    def render_history(history):
+        """Render chat history with images and proper formatting"""
+        rendered = []
+        for user_msg, bot_msg, image_links in history:
+            # Apply proper styling to messages
+            user_html = f"<div class='user-msg'>{user_msg}</div>"
+
+            # Special formatting for lesson plans
+            if "Lesson Plan:" in bot_msg:
+                bot_html = f"<div class='lesson-plan'>{bot_msg}</div>"
+            else:
+                bot_html = f"<div class='bot-msg'>{bot_msg}</div>"
+
+            # Add images if available
+            if image_links:
+                images_html = "".join(
+                    f"<img src='{url}' class='chat-image' onclick='showImage(\"{url}\")' />"
+                    for url in image_links
+                )
+                bot_html += f"<br><br><b>📸 Related Visuals:</b><br><div style='display: flex; flex-wrap: wrap;'>{images_html}</div>"
+
+            rendered.append((user_html, bot_html))
+        return rendered
+
+    def respond(message, chat_hist, chat, student, image, lesson,
+               tokens, student_q, image_q, image_upload, image_url,
+               include_visuals, num_imgs):
+        # If in lesson planning mode, skip this handler
+        if lesson:
+            return chat_hist, message
+
+        # Determine the actual question based on mode
+        if chat:
+            actual_question = message
+        elif student:
+            actual_question = student_q
+        elif image:
+            actual_question = image_q
+        else:
+            actual_question = message
+
+        # Immediately show user question in chat
+        typing_html = "<div class='typing-indicator'><div class='typing-dot'></div><div class='typing-dot'></div><div class='typing-dot'></div></div>"
+        chat_hist.append((actual_question, typing_html, []))
+        yield render_history(chat_hist), ""
+
+        if chat:
+            # General chat mode
+            full_response = ""
+            for chunk in ai_system.stream_answer(message, tokens):
+                full_response = chunk
+                # Update with current response
+                chat_hist[-1] = (actual_question, full_response, [])
+                yield render_history(chat_hist), ""
+
+            # Fetch images if requested
+            image_links = []
+            if include_visuals and num_imgs > 0:
+                image_links = ai_system.fetch_images(message, num_imgs)
+
+            # Update with final response and images
+            chat_hist[-1] = (actual_question, full_response, image_links)
+            yield render_history(chat_hist), ""
+
+        elif student:
+            # Student analytics mode
+            if ai_system.current_df is None:
+                chat_hist[-1] = (actual_question, "⚠️ Please upload a student data file first", [])
+                yield render_history(chat_hist), ""
+            else:
+                response = ""
+                for chunk in ai_system.analyze_student_data(student_q):
+                    response = chunk
+                    chat_hist[-1] = (actual_question, response, [])
+                    yield render_history(chat_hist), ""
+
+        elif image:
+            # Image analysis mode
+            if not image_upload and not image_url:
+                chat_hist[-1] = (actual_question, "⚠️ Please upload an image or enter a URL", [])
+                yield render_history(chat_hist), ""
+            else:
+                try:
+                    result = ai_system.analyze_image(image_upload, image_url, image_q)
+                    chat_hist[-1] = (actual_question, result, [])
+                    yield render_history(chat_hist), ""
+                except Exception as e:
+                    error_msg = f"❌ Error analyzing image: {str(e)}"
+                    chat_hist[-1] = (actual_question, error_msg, [])
+                    yield render_history(chat_hist), ""
+
+        # Trim history if too long
+        if len(chat_hist) > MAX_HISTORY_TURNS:
+            chat_hist = chat_hist[-MAX_HISTORY_TURNS:]
+
+        yield render_history(chat_hist), ""
+
+    def generate_lesson_plan(topic, duration, instructions, chat_hist):
+        if not topic:
+            return chat_hist, "⚠️ Please enter a lesson topic"
+
+        # Show processing message
+        processing_msg = "<div class='typing-indicator'><div class='typing-dot'></div><div class='typing-dot'></div><div class='typing-dot'></div></div>"
+        chat_hist.append((f"Generate lesson plan for: {topic}", processing_msg, []))
+        yield render_history(chat_hist), ""
+
+        # Generate the plan
+        plan = ai_system.generate_lesson_plan(topic, duration, instructions)
+
+        # Format with proper headings
+        formatted_plan = f"""
+        <div class='lesson-plan'>
+            <div class='lesson-title'>📝 Lesson Plan: {topic} ({duration} periods)</div>
+            {plan}
+        </div>
+        """
+
+        # Update chat history with final plan
+        chat_hist[-1] = (
+            f"Generate lesson plan for: {topic}",
+            formatted_plan,
+            []
+        )
+        yield render_history(chat_hist), ""
+
+    # Mode toggles
+    chat_mode.change(fn=toggle_modes, inputs=[chat_mode, student_mode, image_mode, lesson_mode],
+                   outputs=[chat_inputs, student_inputs, image_inputs, lesson_inputs])
+    student_mode.change(fn=toggle_modes, inputs=[chat_mode, student_mode, image_mode, lesson_mode],
+                      outputs=[chat_inputs, student_inputs, image_inputs, lesson_inputs])
+    image_mode.change(fn=toggle_modes, inputs=[chat_mode, student_mode, image_mode, lesson_mode],
+                    outputs=[chat_inputs, student_inputs, image_inputs, lesson_inputs])
+    lesson_mode.change(fn=toggle_modes, inputs=[chat_mode, student_mode, image_mode, lesson_mode],
+                     outputs=[chat_inputs, student_inputs, image_inputs, lesson_inputs])
+
+    # File upload handler
+    file_upload.change(fn=load_student_file, inputs=file_upload, outputs=student_status)
+
+    # Document upload handler
+    doc_upload.change(fn=process_document, inputs=doc_upload, outputs=doc_status)
+
+    # Voice transcription
+    def transcribe_audio(audio):
+        return ai_system.transcribe(audio)
+
+    mic_btn.click(fn=transcribe_audio, inputs=mic, outputs=user_input)
+
+    # Submit handler
+    submit_btn.click(
+        fn=respond,
+        inputs=[
+            user_input, chat_state, chat_mode, student_mode, image_mode, lesson_mode,
+            max_tokens, student_question, image_question, image_upload, image_url,
+            include_images, num_images
+        ],
+        outputs=[chatbot, user_input]
+    )
+
+    # Lesson plan generation button
+    generate_btn.click(
+        fn=generate_lesson_plan,
+        inputs=[topic_input, duration_input, additional_instructions, chat_state],
+        outputs=[chatbot, topic_input]
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True, debug=True)

requirements.txt

@@ -1,6 +1,15 @@
-gradio==4.26.0
-openvino-genai>=1.0.0
-librosa>=0.10.0
-numpy>=1.24.0
-scipy>=1.10.0
-huggingface_hub>=0.21.4
+gradio==4.26.0
+openvino-genai>=1.0.0
+librosa==0.10.0
+numpy>=1.24.0
+scipy>=1.10.0
+huggingface_hub>=0.21.4
+google-api-python-client>=2.0.0
+pandas>=2.0.0
+requests>=2.31.0
+Pillow>=10.0.0
+py-cpuinfo>=9.0.0
+openvino>=2023.2.0
+PyPDF2>=3.0.0
+python-docx>=1.1.0
+soundfile>=0.12.0