Upload 15 files

.env

@@ -0,0 +1,10 @@
+GOOGLE_API_KEY=AIzaSyAsiDT8HYL-eQf19ePi0yoCg6H9gMdYMZk
+TAVILY_API_KEY=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
+LANGSMITH_TRACING=true
+LANGSMITH_ENDPOINT="https://api.smith.langchain.com"
+LANGSMITH_API_KEY="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"
+LANGSMITH_PROJECT="pr-proper-venue-61"
+LANGCHAIN_TRACING_V2=true
+LANGCHAIN_ENDPOINT="https://api.smith.langchain.com"    
+MISTRAL_API_KEY=CRYAdmnhV0rAQcf36jLcjxKDCd50NCOM
+OPENAI_API_KEY=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

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+generated-icon.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,14 +1,4 @@
----
-title: AI Tutor
-emoji: 📊
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 5.33.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: AI tutor
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+title: AI tutor
+sdk: gradio
+app_file: main.py
+pinned: false

app/__init__.py

@@ -0,0 +1,6 @@
+"""
+AI Tutor Application
+Converts PDFs into interactive lectures with voice narration and RAG chatbot functionality
+"""
+
+__version__ = "1.0.0"

app/chatbot.py

@@ -0,0 +1,255 @@
+import openai
+import os
+import logging
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+from app.models import ChatMessage, ChatSession
+from app.rag_system import RAGSystem
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+class RAGChatbot:
+    """RAG-powered chatbot with memory of PDF and lecture content"""
+    
+    def __init__(self):
+        self.client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY", ""))
+        self.rag_system = RAGSystem()
+        self.sessions: Dict[str, ChatSession] = {}
+        self.max_context_length = 8000  # Token limit for context
+    
+    def create_session(self, session_id: str, pdf_content: str = None, lecture_content: str = None) -> bool:
+        """Create a new chat session with optional PDF and lecture content"""
+        try:
+            session = ChatSession(
+                session_id=session_id,
+                pdf_content=pdf_content,
+                lecture_content=lecture_content
+            )
+            
+            self.sessions[session_id] = session
+            
+            # Add content to RAG system if provided
+            if pdf_content:
+                self.rag_system.add_pdf_content(session_id, pdf_content)
+            
+            if lecture_content:
+                self.rag_system.add_lecture_content(session_id, lecture_content)
+            
+            logger.info(f"Created chat session {session_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to create session {session_id}: {str(e)}")
+            return False
+    
+    def add_message(self, session_id: str, role: str, content: str) -> bool:
+        """Add a message to the session history"""
+        try:
+            if session_id not in self.sessions:
+                return False
+            
+            message = ChatMessage(role=role, content=content)
+            self.sessions[session_id].messages.append(message)
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to add message to session {session_id}: {str(e)}")
+            return False
+    
+    def get_response(self, session_id: str, user_message: str) -> Dict[str, Any]:
+        """Generate a response to user message using RAG"""
+        try:
+            if session_id not in self.sessions:
+                return {
+                    'success': False,
+                    'error': 'Session not found',
+                    'response': ''
+                }
+            
+            session = self.sessions[session_id]
+            
+            # Add user message to history
+            self.add_message(session_id, "user", user_message)
+            
+            # Retrieve relevant content
+            retrieval_result = self.rag_system.retrieve_relevant_content(
+                session_id, user_message, n_results=5
+            )
+            
+            if not retrieval_result['success']:
+                logger.warning(f"Content retrieval failed for session {session_id}")
+                relevant_content = []
+            else:
+                relevant_content = retrieval_result['results']
+            
+            # Generate response
+            response = self._generate_response(session, user_message, relevant_content)
+            
+            # Add assistant response to history
+            self.add_message(session_id, "assistant", response)
+            
+            return {
+                'success': True,
+                'response': response,
+                'sources_used': len(relevant_content),
+                'session_id': session_id
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to generate response for session {session_id}: {str(e)}")
+            return {
+                'success': False,
+                'error': str(e),
+                'response': 'I apologize, but I encountered an error while processing your message. Please try again.'
+            }
+    
+    def _generate_response(self, session: ChatSession, user_message: str, relevant_content: List[Dict]) -> str:
+        """Generate response using OpenAI with RAG context"""
+        try:
+            # Build context from relevant content
+            context_parts = []
+            
+            if relevant_content:
+                context_parts.append("Relevant information from your documents:")
+                for i, item in enumerate(relevant_content[:3], 1):  # Limit to top 3 results
+                    source = "PDF" if item['source'] == 'pdf' else "Lecture"
+                    context_parts.append(f"{i}. [{source}] {item['content'][:500]}...")
+                context_parts.append("")
+            
+            # Build conversation history (limited to recent messages)
+            conversation_history = []
+            recent_messages = session.messages[-6:]  # Last 6 messages for context
+            
+            for msg in recent_messages[:-1]:  # Exclude the current user message
+                conversation_history.append(f"{msg.role.title()}: {msg.content}")
+            
+            # Create system prompt
+            system_prompt = """You are a helpful AI assistant that can answer questions about uploaded PDF documents and generated lectures. 
+
+Key guidelines:
+1. Use the provided relevant information to answer questions accurately
+2. If you don't have enough information in the context, say so clearly
+3. Maintain a conversational and educational tone
+4. Reference the source (PDF or Lecture) when appropriate
+5. Be concise but thorough in your explanations
+6. If asked about something not in the documents, explain that your knowledge is limited to the uploaded content
+
+Always strive to be helpful while being honest about the limitations of your knowledge."""
+            
+            # Build the full prompt
+            messages = [{"role": "system", "content": system_prompt}]
+            
+            # Add context if available
+            if context_parts:
+                context_message = "\n".join(context_parts)
+                messages.append({"role": "system", "content": context_message})
+            
+            # Add conversation history
+            if conversation_history:
+                history_message = "Previous conversation:\n" + "\n".join(conversation_history)
+                messages.append({"role": "system", "content": history_message})
+            
+            # Add current user message
+            messages.append({"role": "user", "content": user_message})
+            
+            # Generate response
+            response = self.client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=messages,
+                temperature=0.7,
+                max_tokens=1000
+            )
+            
+            return response.choices[0].message.content
+            
+        except Exception as e:
+            logger.error(f"Response generation failed: {str(e)}")
+            return "I apologize, but I'm having trouble generating a response right now. Please try rephrasing your question."
+    
+    def get_session_history(self, session_id: str) -> List[Dict[str, Any]]:
+        """Get chat history for a session"""
+        try:
+            if session_id not in self.sessions:
+                return []
+            
+            session = self.sessions[session_id]
+            return [
+                {
+                    'role': msg.role,
+                    'content': msg.content,
+                    'timestamp': msg.timestamp.isoformat()
+                }
+                for msg in session.messages
+            ]
+            
+        except Exception as e:
+            logger.error(f"Failed to get session history {session_id}: {str(e)}")
+            return []
+    
+    def clear_session(self, session_id: str) -> bool:
+        """Clear a chat session and its data"""
+        try:
+            # Clear from RAG system
+            self.rag_system.clear_session_data(session_id)
+            
+            # Remove from local sessions
+            if session_id in self.sessions:
+                del self.sessions[session_id]
+            
+            logger.info(f"Cleared session {session_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to clear session {session_id}: {str(e)}")
+            return False
+    
+    def get_session_stats(self, session_id: str) -> Dict[str, Any]:
+        """Get statistics about a session"""
+        try:
+            if session_id not in self.sessions:
+                return {'exists': False}
+            
+            session = self.sessions[session_id]
+            rag_stats = self.rag_system.get_session_stats(session_id)
+            
+            return {
+                'exists': True,
+                'message_count': len(session.messages),
+                'created_at': session.created_at.isoformat(),
+                'has_pdf': session.pdf_content is not None,
+                'has_lecture': session.lecture_content is not None,
+                **rag_stats
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to get session stats {session_id}: {str(e)}")
+            return {'exists': False, 'error': str(e)}
+    
+    def update_session_content(self, session_id: str, pdf_content: str = None, lecture_content: str = None) -> bool:
+        """Update session with new content"""
+        try:
+            if session_id not in self.sessions:
+                return False
+            
+            session = self.sessions[session_id]
+            
+            # Update PDF content
+            if pdf_content:
+                session.pdf_content = pdf_content
+                self.rag_system.add_pdf_content(session_id, pdf_content)
+            
+            # Update lecture content
+            if lecture_content:
+                session.lecture_content = lecture_content
+                self.rag_system.add_lecture_content(session_id, lecture_content)
+            
+            logger.info(f"Updated content for session {session_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to update session content {session_id}: {str(e)}")
+            return False

app/gradio_interface.py

@@ -0,0 +1,396 @@
+import gradio as gr
+import os
+import uuid
+import tempfile
+from typing import Dict, Any, Optional, Tuple
+import logging
+from datetime import datetime
+
+from app.pdf_processor import PDFProcessor
+from app.lecture_generator import LectureGenerator
+from app.voice_synthesizer import VoiceSynthesizer
+from app.chatbot import RAGChatbot
+
+logger = logging.getLogger(__name__)
+
+# Initialize components
+pdf_processor = PDFProcessor()
+lecture_generator = LectureGenerator()
+voice_synthesizer = VoiceSynthesizer()
+chatbot = RAGChatbot()
+
+# Global state for sessions
+current_session = None
+session_data = {}
+
+def create_gradio_interface():
+    """Create and configure the Gradio interface"""
+    
+    # Custom CSS for better styling
+    css = """
+    .container {
+        max-width: 1200px;
+        margin: 0 auto;
+    }
+    .status-box {
+        padding: 10px;
+        border-radius: 5px;
+        margin: 10px 0;
+    }
+    .success {
+        background-color: #d4edda;
+        border: 1px solid #c3e6cb;
+        color: #155724;
+    }
+    .error {
+        background-color: #f8d7da;
+        border: 1px solid #f5c6cb;
+        color: #721c24;
+    }
+    .processing {
+        background-color: #d1ecf1;
+        border: 1px solid #bee5eb;
+        color: #0c5460;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="AI Tutor") as interface:
+        gr.Markdown("# 🎓 AI Tutor")
+        gr.Markdown("Convert PDFs into interactive lectures with voice narration and chat with your AI tutor about any topic!")
+        
+        # Session state
+        session_id_state = gr.State(value=str(uuid.uuid4()))
+        
+        with gr.Tab("📄 PDF Upload & Processing"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    pdf_upload = gr.File(
+                        label="Upload PDF Document (Optional)",
+                        file_types=[".pdf"],
+                        type="binary"
+                    )
+                    
+                    lecture_style = gr.Dropdown(
+                        choices=["academic", "casual", "detailed"],
+                        value="academic",
+                        label="Lecture Style"
+                    )
+                    
+                    include_examples = gr.Checkbox(
+                        value=True,
+                        label="Include Examples"
+                    )
+                    
+                    learning_objectives = gr.Textbox(
+                        label="Learning Objectives & Topic",
+                        placeholder="What do you want to learn? e.g., 'Machine Learning basics', 'Python programming fundamentals', 'Explain quantum physics concepts'",
+                        lines=3,
+                        max_lines=5
+                    )
+                    
+                    gr.Markdown("**Note:** You can generate a lecture with just learning objectives, or upload a PDF for content-based lectures.")
+                    
+                    process_btn = gr.Button("🚀 Generate Lecture", variant="primary")
+                
+                with gr.Column(scale=2):
+                    processing_status = gr.HTML()
+                    pdf_info = gr.JSON(label="PDF Information")
+        
+        with gr.Tab("📚 Generated Lecture"):
+            with gr.Row():
+                with gr.Column():
+                    lecture_title = gr.Textbox(label="Lecture Title", interactive=False)
+                    lecture_content = gr.Textbox(
+                        label="Lecture Content",
+                        lines=20,
+                        max_lines=30,
+                        interactive=False
+                    )
+                    
+                    with gr.Row():
+                        download_pdf_btn = gr.Button("📄 Download PDF")
+                        download_audio_btn = gr.Button("🎤 Generate & Download Audio")
+                    
+                    pdf_download = gr.File(label="Download Lecture PDF")
+                    audio_download = gr.File(label="Download Audio Lecture")
+        
+        with gr.Tab("💬 Tutor Chat"):
+            with gr.Row():
+                with gr.Column(scale=3):
+                    chatbot_interface = gr.Chatbot(
+                        label="Chat with your AI Tutor about your content",
+                        height=400,
+                        type="messages"
+                    )
+                    
+                    with gr.Row():
+                        msg_input = gr.Textbox(
+                            label="Your Message",
+                            placeholder="Ask your AI tutor about any topic, PDF content, or lecture...",
+                            scale=4
+                        )
+                        send_btn = gr.Button("Send", scale=1)
+                    
+                    clear_chat_btn = gr.Button("Clear Chat History")
+                
+                with gr.Column(scale=1):
+                    chat_stats = gr.JSON(label="Session Statistics")
+                    refresh_stats_btn = gr.Button("Refresh Stats")
+        
+        # Event handlers
+        def process_pdf_handler(pdf_file, style, examples, learning_objectives, session_id):
+            """Handle PDF processing or topic-based lecture generation"""
+            global session_data
+            
+            try:
+                # Check if we have either PDF or learning objectives
+                if pdf_file is None and not learning_objectives.strip():
+                    return (
+                        '<div class="status-box error">❌ Please either upload a PDF file or provide learning objectives</div>',
+                        {},
+                        session_id
+                    )
+                
+                # Update status based on input type
+                if pdf_file is not None:
+                    status_html = '<div class="status-box processing">🔄 Processing PDF...</div>'
+                    
+                    # Validate PDF
+                    validation = pdf_processor.validate_pdf(pdf_file)
+                    if not validation['valid']:
+                        return (
+                            f'<div class="status-box error">❌ {validation["error"]}</div>',
+                            {},
+                            session_id
+                        )
+                    
+                    # Extract text
+                    extraction_result = pdf_processor.extract_text_from_pdf(pdf_file)
+                    if not extraction_result['success']:
+                        return (
+                            f'<div class="status-box error">❌ {extraction_result["error"]}</div>',
+                            {},
+                            session_id
+                        )
+                    
+                    pdf_content = extraction_result['text']
+                    pdf_data = extraction_result
+                else:
+                    # Generate lecture from learning objectives only
+                    status_html = '<div class="status-box processing">🔄 Generating lecture from learning objectives...</div>'
+                    pdf_content = ""
+                    pdf_data = {
+                        'success': True,
+                        'text': "",
+                        'metadata': {'total_pages': 0, 'title': learning_objectives[:50], 'author': '', 'subject': ''},
+                        'word_count': 0,
+                        'character_count': 0
+                    }
+                
+                # Generate lecture
+                lecture_result = lecture_generator.generate_lecture(
+                    pdf_content,
+                    style=style,
+                    include_examples=examples,
+                    learning_objectives=learning_objectives
+                )
+                
+                if not lecture_result['success']:
+                    return (
+                        f'<div class="status-box error">❌ Lecture generation failed: {lecture_result["error"]}</div>',
+                        {},
+                        session_id
+                    )
+                
+                # Store session data
+                session_data[session_id] = {
+                    'pdf_data': pdf_data,
+                    'lecture_data': lecture_result,
+                    'processed_at': datetime.now().isoformat()
+                }
+                
+                # Create chatbot session
+                chatbot.create_session(
+                    session_id,
+                    pdf_content=pdf_content,
+                    lecture_content=lecture_result['content']
+                )
+                
+                if pdf_file is not None:
+                    success_html = '<div class="status-box success">✅ PDF processed successfully!</div>'
+                    info = {
+                        'filename': getattr(pdf_file, 'name', 'uploaded_file.pdf'),
+                        'pages': pdf_data['metadata']['total_pages'],
+                        'word_count': pdf_data['word_count'],
+                        'lecture_title': lecture_result['title'],
+                        'estimated_duration': f"{lecture_result['estimated_duration']} minutes"
+                    }
+                else:
+                    success_html = '<div class="status-box success">✅ Lecture generated from learning objectives!</div>'
+                    info = {
+                        'source': 'Learning Objectives',
+                        'topic': learning_objectives[:100] + "..." if len(learning_objectives) > 100 else learning_objectives,
+                        'lecture_title': lecture_result['title'],
+                        'estimated_duration': f"{lecture_result['estimated_duration']} minutes"
+                    }
+                
+                return success_html, info, session_id
+                
+            except Exception as e:
+                logger.error(f"PDF processing error: {str(e)}")
+                return (
+                    f'<div class="status-box error">❌ Processing failed: {str(e)}</div>',
+                    {},
+                    session_id
+                )
+        
+        def update_lecture_display(session_id):
+            """Update lecture display with generated content"""
+            global session_data
+            
+            if session_id not in session_data:
+                return "", ""
+            
+            lecture_data = session_data[session_id]['lecture_data']
+            return lecture_data['title'], lecture_data['content']
+        
+        def generate_pdf_download(session_id):
+            """Generate PDF download"""
+            global session_data
+            
+            try:
+                if session_id not in session_data:
+                    return None
+                
+                lecture_data = session_data[session_id]['lecture_data']
+                
+                # Generate PDF
+                output_path = os.path.join("output", f"lecture_{session_id}.pdf")
+                success = lecture_generator.generate_pdf(lecture_data, output_path)
+                
+                if success:
+                    return output_path
+                else:
+                    return None
+                    
+            except Exception as e:
+                logger.error(f"PDF generation error: {str(e)}")
+                return None
+        
+        def generate_audio_download(session_id):
+            """Generate audio download"""
+            global session_data
+            
+            try:
+                if session_id not in session_data:
+                    return None
+                
+                lecture_data = session_data[session_id]['lecture_data']
+                
+                # Generate audio
+                output_path = os.path.join("output", f"lecture_audio_{session_id}.mp3")
+                result = voice_synthesizer.synthesize_lecture(
+                    lecture_data['content'],
+                    voice="nova",
+                    output_path=output_path
+                )
+                
+                if result['success']:
+                    return result['file_path']
+                else:
+                    return None
+                    
+            except Exception as e:
+                logger.error(f"Audio generation error: {str(e)}")
+                return None
+        
+        def chat_handler(message, history, session_id):
+            """Handle chat messages"""
+            if not message.strip():
+                return history, ""
+            
+            try:
+                response_result = chatbot.get_response(session_id, message)
+                
+                if response_result['success']:
+                    history.append({"role": "user", "content": message})
+                    history.append({"role": "assistant", "content": response_result['response']})
+                else:
+                    history.append({"role": "user", "content": message})
+                    history.append({"role": "assistant", "content": f"Error: {response_result['error']}"})
+                
+                return history, ""
+                
+            except Exception as e:
+                logger.error(f"Chat error: {str(e)}")
+                history.append({"role": "user", "content": message})
+                history.append({"role": "assistant", "content": f"Sorry, I encountered an error: {str(e)}"})
+                return history, ""
+        
+        def clear_chat_handler(session_id):
+            """Clear chat history"""
+            chatbot.clear_session(session_id)
+            new_session_id = str(uuid.uuid4())
+            
+            # Recreate session with existing content if available
+            if session_id in session_data:
+                pdf_content = session_data[session_id]['pdf_data']['text']
+                lecture_content = session_data[session_id]['lecture_data']['content']
+                chatbot.create_session(new_session_id, pdf_content, lecture_content)
+                session_data[new_session_id] = session_data[session_id]
+                del session_data[session_id]
+            
+            return [], new_session_id
+        
+        def get_chat_stats(session_id):
+            """Get chat statistics"""
+            return chatbot.get_session_stats(session_id)
+        
+        # Wire up event handlers
+        process_btn.click(
+            fn=process_pdf_handler,
+            inputs=[pdf_upload, lecture_style, include_examples, learning_objectives, session_id_state],
+            outputs=[processing_status, pdf_info, session_id_state]
+        ).then(
+            fn=update_lecture_display,
+            inputs=[session_id_state],
+            outputs=[lecture_title, lecture_content]
+        )
+        
+        download_pdf_btn.click(
+            fn=generate_pdf_download,
+            inputs=[session_id_state],
+            outputs=[pdf_download]
+        )
+        
+        download_audio_btn.click(
+            fn=generate_audio_download,
+            inputs=[session_id_state],
+            outputs=[audio_download]
+        )
+        
+        send_btn.click(
+            fn=chat_handler,
+            inputs=[msg_input, chatbot_interface, session_id_state],
+            outputs=[chatbot_interface, msg_input]
+        )
+        
+        msg_input.submit(
+            fn=chat_handler,
+            inputs=[msg_input, chatbot_interface, session_id_state],
+            outputs=[chatbot_interface, msg_input]
+        )
+        
+        clear_chat_btn.click(
+            fn=clear_chat_handler,
+            inputs=[session_id_state],
+            outputs=[chatbot_interface, session_id_state]
+        )
+        
+        refresh_stats_btn.click(
+            fn=get_chat_stats,
+            inputs=[session_id_state],
+            outputs=[chat_stats]
+        )
+    
+    return interface

app/lecture_generator.py

@@ -0,0 +1,538 @@
+from langgraph.graph import Graph, START, END
+from langgraph.graph.message import add_messages
+from typing_extensions import TypedDict, Annotated
+from typing import Dict, List, Any, Optional
+import openai
+import os
+import logging
+from datetime import datetime
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, PageBreak
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.lib.colors import HexColor
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+# Set up OpenAI client
+openai.api_key = os.getenv("OPENAI_API_KEY", "")
+
+class LectureState(TypedDict):
+    pdf_content: str
+    style: str
+    include_examples: bool
+    learning_objectives: str
+    analysis: Dict[str, Any]
+    outline: Dict[str, Any]
+    sections: List[Dict[str, Any]]
+    lecture_content: str
+    title: str
+    metadata: Dict[str, Any]
+    messages: Annotated[list, add_messages]
+
+class LectureGenerator:
+    """AI agent for converting PDF content into structured lectures using LangGraph"""
+    
+    def __init__(self):
+        self.client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY", ""))
+        self.graph = self._build_graph()
+    
+    def _build_graph(self) -> Graph:
+        """Build the LangGraph workflow for lecture generation"""
+        workflow = Graph()
+        
+        # Add nodes
+        workflow.add_node("analyze_content", self._analyze_content)
+        workflow.add_node("create_outline", self._create_outline)
+        workflow.add_node("generate_sections", self._generate_sections)
+        workflow.add_node("compile_lecture", self._compile_lecture)
+        workflow.add_node("finalize_output", self._finalize_output)
+        
+        # Add edges
+        workflow.add_edge(START, "analyze_content")
+        workflow.add_edge("analyze_content", "create_outline")
+        workflow.add_edge("create_outline", "generate_sections")
+        workflow.add_edge("generate_sections", "compile_lecture")
+        workflow.add_edge("compile_lecture", "finalize_output")
+        workflow.add_edge("finalize_output", END)
+        
+        return workflow.compile()
+    
+    def generate_lecture(self, pdf_content: str, style: str = "academic", include_examples: bool = True, learning_objectives: str = "") -> Dict[str, Any]:
+        """Generate a structured lecture from PDF content"""
+        try:
+            initial_state = LectureState(
+                pdf_content=pdf_content,
+                style=style,
+                include_examples=include_examples,
+                learning_objectives=learning_objectives,
+                analysis={},
+                outline={},
+                sections=[],
+                lecture_content="",
+                title="",
+                metadata={},
+                messages=[]
+            )
+            
+            # Run the graph
+            result = self.graph.invoke(initial_state)
+            
+            return {
+                'success': True,
+                'title': result['title'],
+                'content': result['lecture_content'],
+                'sections': result['sections'],
+                'metadata': result['metadata'],
+                'word_count': len(result['lecture_content'].split()),
+                'estimated_duration': self._estimate_duration(result['lecture_content'])
+            }
+            
+        except Exception as e:
+            logger.error(f"Lecture generation failed: {str(e)}")
+            return {
+                'success': False,
+                'error': str(e),
+                'title': '',
+                'content': '',
+                'sections': [],
+                'metadata': {},
+                'word_count': 0,
+                'estimated_duration': 0
+            }
+    
+    def _analyze_content(self, state: LectureState) -> LectureState:
+        """Analyze content or learning objectives to understand structure and main topics"""
+        try:
+            if state['pdf_content'].strip():
+                # PDF-based analysis
+                learning_context = f"\n\nUser Learning Objectives: {state['learning_objectives']}" if state['learning_objectives'].strip() else ""
+                
+                prompt = f"""
+                Analyze the following document content and provide a structured analysis:
+                
+                Content: {state['pdf_content'][:5000]}...{learning_context}
+                
+                Please provide:
+                1. Main topic/subject
+                2. Key themes and concepts
+                3. Document type (research paper, textbook, article, etc.)
+                4. Complexity level (beginner, intermediate, advanced)
+                5. Target audience
+                6. Key learning objectives (consider user's stated objectives if provided)
+                
+                Format your response as a JSON object.
+                """
+            else:
+                # Learning objectives-based analysis
+                prompt = f"""
+                Create a structured analysis for a lecture based on these learning objectives:
+                
+                Learning Objectives: {state['learning_objectives']}
+                
+                Please provide:
+                1. Main topic/subject (extracted from learning objectives)
+                2. Key themes and concepts that should be covered
+                3. Document type: "educational lecture"
+                4. Complexity level (beginner, intermediate, advanced) based on objectives
+                5. Target audience (inferred from objectives)
+                6. Detailed learning objectives breakdown
+                
+                Format your response as a JSON object.
+                """
+            
+            response = self.client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.3
+            )
+            
+            # Parse the analysis
+            import json
+            try:
+                analysis = json.loads(response.choices[0].message.content)
+            except:
+                # Fallback parsing if JSON parsing fails
+                if state['learning_objectives'].strip():
+                    # Extract topic from learning objectives
+                    topic = state['learning_objectives'].split('.')[0].split(',')[0][:50]
+                    main_topic = topic if topic else "Educational Lecture"
+                else:
+                    main_topic = "Document Analysis"
+                
+                analysis = {
+                    "main_topic": main_topic,
+                    "key_themes": ["Content Summary"],
+                    "document_type": "Document",
+                    "complexity_level": "intermediate",
+                    "target_audience": "General",
+                    "learning_objectives": ["Understand main concepts"]
+                }
+            
+            state['analysis'] = analysis
+            return state
+            
+        except Exception as e:
+            logger.error(f"Content analysis failed: {str(e)}")
+            if state['learning_objectives'].strip():
+                # Extract topic from learning objectives for fallback
+                topic = state['learning_objectives'].split('.')[0].split(',')[0][:50]
+                main_topic = topic if topic else "Educational Lecture"
+            else:
+                main_topic = "Document Analysis"
+            
+            state['analysis'] = {
+                "main_topic": main_topic,
+                "key_themes": ["Content Summary"],
+                "document_type": "Document",
+                "complexity_level": "intermediate",
+                "target_audience": "General",
+                "learning_objectives": ["Understand main concepts"]
+            }
+            return state
+    
+    def _create_outline(self, state: LectureState) -> LectureState:
+        """Create a detailed lecture outline based on analysis"""
+        try:
+            analysis = state['analysis']
+            style = state['style']
+            
+            learning_context = f"\n\nUser Learning Objectives: {state['learning_objectives']}" if state['learning_objectives'].strip() else ""
+            
+            prompt = f"""
+            Based on this analysis, create a detailed lecture outline:
+            
+            Analysis: {analysis}
+            Style: {style}
+            Include Examples: {state['include_examples']}{learning_context}
+            
+            Create an outline with:
+            1. Engaging title that reflects user's learning goals
+            2. Introduction section
+            3. 3-5 main sections with subsections (prioritize user's stated learning objectives)
+            4. Conclusion section
+            5. Estimated time for each section
+            
+            Format as JSON with sections array containing title, subsections, and duration.
+            """
+            
+            response = self.client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.4
+            )
+            
+            import json
+            try:
+                outline = json.loads(response.choices[0].message.content)
+            except:
+                # Fallback outline with proper title
+                title = analysis.get("main_topic", "Educational Lecture")
+                if state['learning_objectives'].strip() and not state['pdf_content'].strip():
+                    # For learning objectives only, create a more descriptive title
+                    objectives_words = state['learning_objectives'].split()[:5]  # First 5 words
+                    title = " ".join(objectives_words).title()
+                
+                outline = {
+                    "title": title,
+                    "sections": [
+                        {"title": "Introduction", "subsections": ["Overview"], "duration": 5},
+                        {"title": "Core Concepts", "subsections": ["Key Points"], "duration": 15},
+                        {"title": "Conclusion", "subsections": ["Summary"], "duration": 5}
+                    ]
+                }
+            
+            state['outline'] = outline
+            state['title'] = outline.get('title', 'Generated Lecture')
+            return state
+            
+        except Exception as e:
+            logger.error(f"Outline creation failed: {str(e)}")
+            # Generate appropriate fallback title based on learning objectives
+            if state['learning_objectives'].strip():
+                objectives_words = state['learning_objectives'].split()[:5]
+                title = " ".join(objectives_words).title() if objectives_words else "Educational Lecture"
+            else:
+                title = "Generated Lecture"
+            
+            state['outline'] = {
+                "title": title,
+                "sections": [
+                    {"title": "Introduction", "subsections": ["Overview"], "duration": 5},
+                    {"title": "Core Concepts", "subsections": ["Key Points"], "duration": 15},
+                    {"title": "Conclusion", "subsections": ["Summary"], "duration": 5}
+                ]
+            }
+            state['title'] = title
+            return state
+    
+    def _generate_sections(self, state: LectureState) -> LectureState:
+        """Generate detailed content for each section"""
+        try:
+            sections = []
+            outline = state['outline']
+            pdf_content = state['pdf_content']
+            style = state['style']
+            
+            for section in outline.get('sections', []):
+                learning_context = f"\n\nUser Learning Objectives: {state['learning_objectives']}" if state['learning_objectives'].strip() else ""
+                
+                if pdf_content.strip():
+                    # PDF-based section generation
+                    section_prompt = f"""
+                    Generate detailed content for this lecture section:
+                    
+                    Section Title: {section['title']}
+                    Subsections: {section.get('subsections', [])}
+                    Style: {style}
+                    Include Examples: {state['include_examples']}{learning_context}
+                    
+                    Source Material: {pdf_content[:3000]}...
+                    
+                    Create engaging, educational content that:
+                    1. Explains concepts clearly (focus on user's learning objectives if provided)
+                    2. Includes relevant examples if requested
+                    3. Uses appropriate tone for {style} style
+                    4. Builds logically on previous sections
+                    5. Addresses the user's specific learning goals
+                    
+                    Format with clear headings and structured paragraphs.
+                    """
+                else:
+                    # Learning objectives-based section generation
+                    section_prompt = f"""
+                    Generate comprehensive educational content for this lecture section:
+                    
+                    Section Title: {section['title']}
+                    Subsections: {section.get('subsections', [])}
+                    Style: {style}
+                    Include Examples: {state['include_examples']}
+                    Learning Objectives: {state['learning_objectives']}
+                    
+                    Create engaging, educational content that:
+                    1. Thoroughly explains concepts related to the learning objectives
+                    2. Includes practical examples and real-world applications if requested
+                    3. Uses appropriate {style} tone and language
+                    4. Builds logically on previous sections
+                    5. Directly addresses the stated learning objectives
+                    6. Provides comprehensive coverage of the topic
+                    
+                    Format with clear headings and structured paragraphs.
+                    """
+                
+                response = self.client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[{"role": "user", "content": section_prompt}],
+                    temperature=0.5
+                )
+                
+                section_content = response.choices[0].message.content
+                
+                sections.append({
+                    'title': section['title'],
+                    'content': section_content,
+                    'duration': section.get('duration', 10),
+                    'subsections': section.get('subsections', [])
+                })
+            
+            state['sections'] = sections
+            return state
+            
+        except Exception as e:
+            logger.error(f"Section generation failed: {str(e)}")
+            # Create basic fallback sections
+            state['sections'] = [
+                {
+                    'title': 'Introduction',
+                    'content': 'Welcome to this lecture based on the provided document.',
+                    'duration': 5,
+                    'subsections': ['Overview']
+                },
+                {
+                    'title': 'Main Content',
+                    'content': 'Here are the key points from the document.',
+                    'duration': 15,
+                    'subsections': ['Key Points']
+                }
+            ]
+            return state
+    
+    def _compile_lecture(self, state: LectureState) -> LectureState:
+        """Compile all sections into a cohesive lecture"""
+        try:
+            title = state['title']
+            sections = state['sections']
+            
+            # Create dynamic introduction based on content type
+            if state['pdf_content'].strip():
+                # PDF-based lecture introduction
+                intro = f"""# {title}
+            
+Welcome to this comprehensive lecture on {title}. This presentation has been crafted from your uploaded document to provide you with a thorough understanding of the key concepts and insights.
+
+## Learning Objectives
+By the end of this lecture, you will be able to:
+- Understand the main concepts presented in the source material
+- Apply the knowledge to practical situations
+- Engage in meaningful discussions about the topic
+
+---
+"""
+            else:
+                # Topic-based lecture introduction
+                learning_goals = state['learning_objectives'][:200] + "..." if len(state['learning_objectives']) > 200 else state['learning_objectives']
+                intro = f"""# {title}
+            
+Welcome to this comprehensive lecture on {title}. This presentation has been crafted to address your specific learning objectives and provide you with a thorough understanding of the topic.
+
+## Your Learning Goals
+{learning_goals}
+
+## What You'll Learn
+By the end of this lecture, you will be able to:
+- Master the concepts you've requested to learn
+- Apply this knowledge to real-world scenarios
+- Build upon these foundations for further learning
+
+---
+"""
+            
+            # Compile all sections
+            compiled_content = intro
+            for i, section in enumerate(sections, 1):
+                compiled_content += f"\n## {i}. {section['title']}\n\n"
+                compiled_content += section['content']
+                compiled_content += "\n\n---\n"
+            
+            # Add conclusion
+            compiled_content += """
+## Conclusion
+
+Thank you for joining this lecture. We've covered the essential concepts and insights from the source material. Remember to review the key points and consider how they apply to your understanding of the subject.
+
+### Key Takeaways
+- Review the main concepts discussed
+- Consider practical applications
+- Engage with additional resources for deeper learning
+
+---
+
+*This lecture was generated using AI to transform written content into an engaging educational experience.*
+"""
+            
+            state['lecture_content'] = compiled_content
+            return state
+            
+        except Exception as e:
+            logger.error(f"Lecture compilation failed: {str(e)}")
+            state['lecture_content'] = f"# {state['title']}\n\nThis is a generated lecture based on the provided document."
+            return state
+    
+    def _finalize_output(self, state: LectureState) -> LectureState:
+        """Finalize the output with metadata"""
+        try:
+            word_count = len(state['lecture_content'].split())
+            
+            state['metadata'] = {
+                'generated_at': datetime.now().isoformat(),
+                'style': state['style'],
+                'include_examples': state['include_examples'],
+                'word_count': word_count,
+                'estimated_duration': self._estimate_duration(state['lecture_content']),
+                'sections_count': len(state['sections']),
+                'analysis': state['analysis']
+            }
+            
+            return state
+            
+        except Exception as e:
+            logger.error(f"Output finalization failed: {str(e)}")
+            state['metadata'] = {
+                'generated_at': datetime.now().isoformat(),
+                'style': state['style'],
+                'include_examples': state['include_examples'],
+                'word_count': 0,
+                'estimated_duration': 0,
+                'sections_count': 0,
+                'analysis': {}
+            }
+            return state
+    
+    def _estimate_duration(self, content: str) -> int:
+        """Estimate lecture duration in minutes based on word count"""
+        word_count = len(content.split())
+        # Assume average speaking rate of 150 words per minute
+        return max(1, round(word_count / 150))
+    
+    def generate_pdf(self, lecture_data: Dict[str, Any], output_path: str) -> bool:
+        """Generate PDF version of the lecture"""
+        try:
+            doc = SimpleDocTemplate(output_path, pagesize=A4)
+            styles = getSampleStyleSheet()
+            
+            # Custom styles
+            title_style = ParagraphStyle(
+                'CustomTitle',
+                parent=styles['Heading1'],
+                fontSize=24,
+                spaceAfter=30,
+                textColor=HexColor('#2C3E50'),
+                alignment=1  # Center alignment
+            )
+            
+            heading_style = ParagraphStyle(
+                'CustomHeading',
+                parent=styles['Heading2'],
+                fontSize=18,
+                spaceAfter=20,
+                spaceBefore=20,
+                textColor=HexColor('#34495E')
+            )
+            
+            content = []
+            
+            # Title
+            content.append(Paragraph(lecture_data['title'], title_style))
+            content.append(Spacer(1, 20))
+            
+            # Metadata
+            metadata_text = f"""
+            <b>Generated:</b> {lecture_data['metadata']['generated_at']}<br/>
+            <b>Style:</b> {lecture_data['metadata']['style'].title()}<br/>
+            <b>Duration:</b> ~{lecture_data['metadata']['estimated_duration']} minutes<br/>
+            <b>Word Count:</b> {lecture_data['metadata']['word_count']}
+            """
+            content.append(Paragraph(metadata_text, styles['Normal']))
+            content.append(Spacer(1, 30))
+            
+            # Process lecture content
+            lecture_lines = lecture_data['content'].split('\n')
+            
+            for line in lecture_lines:
+                line = line.strip()
+                if not line:
+                    content.append(Spacer(1, 12))
+                elif line.startswith('# '):
+                    # Main title (already added)
+                    continue
+                elif line.startswith('## '):
+                    # Section heading
+                    content.append(Paragraph(line[3:], heading_style))
+                elif line.startswith('---'):
+                    # Section separator
+                    content.append(Spacer(1, 20))
+                else:
+                    # Regular content
+                    content.append(Paragraph(line, styles['Normal']))
+                    content.append(Spacer(1, 6))
+            
+            doc.build(content)
+            return True
+            
+        except Exception as e:
+            logger.error(f"PDF generation failed: {str(e)}")
+            return False

app/models.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+
+class ChatMessage(BaseModel):
+    role: str  # "user" or "assistant"
+    content: str
+    timestamp: datetime = datetime.now()
+
+class ChatSession(BaseModel):
+    session_id: str
+    messages: List[ChatMessage] = []
+    pdf_content: Optional[str] = None
+    lecture_content: Optional[str] = None
+    created_at: datetime = datetime.now()
+
+class LectureRequest(BaseModel):
+    pdf_content: str
+    style: str = "academic"  # academic, casual, detailed
+    include_examples: bool = True
+
+class LectureResponse(BaseModel):
+    title: str
+    content: str
+    sections: List[Dict[str, Any]]
+    word_count: int
+    estimated_duration: int  # in minutes
+
+class ProcessingStatus(BaseModel):
+    status: str  # "processing", "completed", "error"
+    progress: int  # 0-100
+    message: str
+    result: Optional[Dict[str, Any]] = None

app/pdf_processor.py

@@ -0,0 +1,189 @@
+import PyPDF2
+import pdfplumber
+from typing import Dict, List, Optional, Union, Any
+import re
+import logging
+import io
+
+logger = logging.getLogger(__name__)
+
+class PDFProcessor:
+    """Handles PDF file processing and text extraction"""
+    
+    def __init__(self):
+        self.supported_formats = ['.pdf']
+    
+    def extract_text_from_pdf(self, pdf_file) -> Dict[str, Any]:
+        """
+        Extract text content from PDF file
+        Returns structured data with text, metadata, and page information
+        """
+        try:
+            # Handle bytes input from Gradio
+            if isinstance(pdf_file, bytes):
+                pdf_file = io.BytesIO(pdf_file)
+            
+            # Try pdfplumber first (better for complex layouts)
+            with pdfplumber.open(pdf_file) as pdf:
+                text_content = []
+                metadata = {
+                    'total_pages': len(pdf.pages),
+                    'title': '',
+                    'author': '',
+                    'subject': ''
+                }
+                
+                # Extract metadata if available
+                if pdf.metadata:
+                    metadata.update({
+                        'title': pdf.metadata.get('Title', ''),
+                        'author': pdf.metadata.get('Author', ''),
+                        'subject': pdf.metadata.get('Subject', '')
+                    })
+                
+                # Extract text from each page
+                for page_num, page in enumerate(pdf.pages, 1):
+                    page_text = page.extract_text()
+                    if page_text:
+                        text_content.append({
+                            'page_number': page_num,
+                            'text': self._clean_text(page_text)
+                        })
+                
+                combined_text = '\n\n'.join([page['text'] for page in text_content])
+                
+                return {
+                    'success': True,
+                    'text': combined_text,
+                    'pages': text_content,
+                    'metadata': metadata,
+                    'word_count': len(combined_text.split()),
+                    'character_count': len(combined_text)
+                }
+                
+        except Exception as e:
+            logger.error(f"pdfplumber extraction failed: {str(e)}")
+            # Fallback to PyPDF2
+            return self._extract_with_pypdf2(pdf_file)
+    
+    def _extract_with_pypdf2(self, pdf_file) -> Dict[str, Any]:
+        """Fallback method using PyPDF2"""
+        try:
+            # Handle bytes input from Gradio
+            if isinstance(pdf_file, bytes):
+                pdf_file = io.BytesIO(pdf_file)
+            else:
+                pdf_file.seek(0)  # Reset file pointer
+            reader = PyPDF2.PdfReader(pdf_file)
+            
+            text_content = []
+            metadata = {
+                'total_pages': len(reader.pages),
+                'title': '',
+                'author': '',
+                'subject': ''
+            }
+            
+            # Extract metadata
+            if reader.metadata:
+                metadata.update({
+                    'title': reader.metadata.get('/Title', ''),
+                    'author': reader.metadata.get('/Author', ''),
+                    'subject': reader.metadata.get('/Subject', '')
+                })
+            
+            # Extract text from each page
+            for page_num, page in enumerate(reader.pages, 1):
+                page_text = page.extract_text()
+                if page_text:
+                    text_content.append({
+                        'page_number': page_num,
+                        'text': self._clean_text(page_text)
+                    })
+            
+            combined_text = '\n\n'.join([page['text'] for page in text_content])
+            
+            return {
+                'success': True,
+                'text': combined_text,
+                'pages': text_content,
+                'metadata': metadata,
+                'word_count': len(combined_text.split()),
+                'character_count': len(combined_text)
+            }
+            
+        except Exception as e:
+            logger.error(f"PyPDF2 extraction failed: {str(e)}")
+            return {
+                'success': False,
+                'error': f"Failed to extract text from PDF: {str(e)}",
+                'text': '',
+                'pages': [],
+                'metadata': {},
+                'word_count': 0,
+                'character_count': 0
+            }
+    
+    def _clean_text(self, text: str) -> str:
+        """Clean and normalize extracted text"""
+        # Remove excessive whitespace
+        text = re.sub(r'\s+', ' ', text)
+        
+        # Remove page numbers and headers/footers (common patterns)
+        text = re.sub(r'\n\d+\n', '\n', text)
+        
+        # Fix common PDF extraction issues
+        text = re.sub(r'([a-z])([A-Z])', r'\1 \2', text)  # Split concatenated words
+        text = re.sub(r'(\w)-\n(\w)', r'\1\2', text)  # Fix hyphenated words across lines
+        
+        # Remove excessive line breaks
+        text = re.sub(r'\n{3,}', '\n\n', text)
+        
+        return text.strip()
+    
+    def validate_pdf(self, pdf_file) -> Dict[str, Any]:
+        """Validate PDF file before processing"""
+        try:
+            # Handle bytes input from Gradio
+            if isinstance(pdf_file, bytes):
+                file_size = len(pdf_file)
+                pdf_file = io.BytesIO(pdf_file)
+            else:
+                # Check file size (limit to 50MB)
+                pdf_file.seek(0, 2)  # Seek to end
+                file_size = pdf_file.tell()
+                pdf_file.seek(0)  # Reset to beginning
+            
+            if file_size > 50 * 1024 * 1024:  # 50MB limit
+                return {
+                    'valid': False,
+                    'error': 'File size exceeds 50MB limit'
+                }
+            
+            # Try to open the PDF to validate format
+            try:
+                reader = PyPDF2.PdfReader(pdf_file)
+                if len(reader.pages) == 0:
+                    return {
+                        'valid': False,
+                        'error': 'PDF contains no pages'
+                    }
+                pdf_file.seek(0)  # Reset file pointer
+                
+                return {
+                    'valid': True,
+                    'pages': len(reader.pages),
+                    'size_mb': round(file_size / (1024 * 1024), 2)
+                }
+                
+            except Exception as e:
+                return {
+                    'valid': False,
+                    'error': f'Invalid PDF format: {str(e)}'
+                }
+                
+        except Exception as e:
+            return {
+                'valid': False,
+                'error': f'Error validating PDF: {str(e)}'
+            }

app/rag_system.py

@@ -0,0 +1,279 @@
+import chromadb
+from chromadb.utils import embedding_functions
+import openai
+import os
+import logging
+from typing import List, Dict, Any, Optional
+import uuid
+from datetime import datetime
+import numpy as np
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+class RAGSystem:
+    """Retrieval-Augmented Generation system for chatbot functionality"""
+    
+    def __init__(self, persist_directory: str = "chroma_db"):
+        self.client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY", ""))
+        
+        # Initialize ChromaDB
+        self.chroma_client = chromadb.PersistentClient(path=persist_directory)
+        
+        # Create embedding function
+        self.embedding_function = embedding_functions.OpenAIEmbeddingFunction(
+            api_key=os.getenv("OPENAI_API_KEY", ""),
+            model_name="text-embedding-ada-002"
+        )
+        
+        # Collections for different document types
+        self.pdf_collection = self._get_or_create_collection("pdf_documents")
+        self.lecture_collection = self._get_or_create_collection("lecture_content")
+        
+    def _get_or_create_collection(self, name: str):
+        """Get existing collection or create new one"""
+        try:
+            return self.chroma_client.get_collection(
+                name=name,
+                embedding_function=self.embedding_function
+            )
+        except:
+            return self.chroma_client.create_collection(
+                name=name,
+                embedding_function=self.embedding_function,
+                metadata={"description": f"Collection for {name}"}
+            )
+    
+    def add_pdf_content(self, session_id: str, pdf_content: str, metadata: Dict[str, Any] = None) -> bool:
+        """Add PDF content to the vector database"""
+        try:
+            # Split content into chunks
+            chunks = self._split_text(pdf_content, chunk_size=1000, overlap=200)
+            
+            # Prepare documents for insertion
+            documents = []
+            metadatas = []
+            ids = []
+            
+            base_metadata = {
+                "session_id": session_id,
+                "document_type": "pdf",
+                "added_at": datetime.now().isoformat(),
+                **(metadata or {})
+            }
+            
+            for i, chunk in enumerate(chunks):
+                doc_id = f"{session_id}_pdf_{i}_{uuid.uuid4().hex[:8]}"
+                
+                documents.append(chunk)
+                metadatas.append({
+                    **base_metadata,
+                    "chunk_index": i,
+                    "chunk_id": doc_id
+                })
+                ids.append(doc_id)
+            
+            # Add to collection
+            self.pdf_collection.add(
+                documents=documents,
+                metadatas=metadatas,
+                ids=ids
+            )
+            
+            logger.info(f"Added {len(chunks)} PDF chunks for session {session_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to add PDF content: {str(e)}")
+            return False
+    
+    def add_lecture_content(self, session_id: str, lecture_content: str, metadata: Dict[str, Any] = None) -> bool:
+        """Add lecture content to the vector database"""
+        try:
+            # Split content into chunks
+            chunks = self._split_text(lecture_content, chunk_size=1000, overlap=200)
+            
+            documents = []
+            metadatas = []
+            ids = []
+            
+            base_metadata = {
+                "session_id": session_id,
+                "document_type": "lecture",
+                "added_at": datetime.now().isoformat(),
+                **(metadata or {})
+            }
+            
+            for i, chunk in enumerate(chunks):
+                doc_id = f"{session_id}_lecture_{i}_{uuid.uuid4().hex[:8]}"
+                
+                documents.append(chunk)
+                metadatas.append({
+                    **base_metadata,
+                    "chunk_index": i,
+                    "chunk_id": doc_id
+                })
+                ids.append(doc_id)
+            
+            # Add to collection
+            self.lecture_collection.add(
+                documents=documents,
+                metadatas=metadatas,
+                ids=ids
+            )
+            
+            logger.info(f"Added {len(chunks)} lecture chunks for session {session_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to add lecture content: {str(e)}")
+            return False
+    
+    def retrieve_relevant_content(self, session_id: str, query: str, n_results: int = 5) -> Dict[str, Any]:
+        """Retrieve relevant content for a query"""
+        try:
+            # Search in both collections
+            pdf_results = self.pdf_collection.query(
+                query_texts=[query],
+                n_results=n_results,
+                where={"session_id": session_id}
+            )
+            
+            lecture_results = self.lecture_collection.query(
+                query_texts=[query],
+                n_results=n_results,
+                where={"session_id": session_id}
+            )
+            
+            # Combine and rank results
+            all_results = []
+            
+            # Process PDF results
+            if pdf_results['documents'] and pdf_results['documents'][0]:
+                for i, doc in enumerate(pdf_results['documents'][0]):
+                    all_results.append({
+                        'content': doc,
+                        'metadata': pdf_results['metadatas'][0][i],
+                        'distance': pdf_results['distances'][0][i],
+                        'source': 'pdf'
+                    })
+            
+            # Process lecture results
+            if lecture_results['documents'] and lecture_results['documents'][0]:
+                for i, doc in enumerate(lecture_results['documents'][0]):
+                    all_results.append({
+                        'content': doc,
+                        'metadata': lecture_results['metadatas'][0][i],
+                        'distance': lecture_results['distances'][0][i],
+                        'source': 'lecture'
+                    })
+            
+            # Sort by relevance (distance)
+            all_results.sort(key=lambda x: x['distance'])
+            
+            return {
+                'success': True,
+                'results': all_results[:n_results],
+                'total_found': len(all_results)
+            }
+            
+        except Exception as e:
+            logger.error(f"Content retrieval failed: {str(e)}")
+            return {
+                'success': False,
+                'results': [],
+                'total_found': 0,
+                'error': str(e)
+            }
+    
+    def _split_text(self, text: str, chunk_size: int = 1000, overlap: int = 200) -> List[str]:
+        """Split text into overlapping chunks"""
+        if len(text) <= chunk_size:
+            return [text]
+        
+        chunks = []
+        start = 0
+        
+        while start < len(text):
+            end = start + chunk_size
+            
+            # Try to end at a sentence boundary
+            if end < len(text):
+                # Look for sentence endings within the last 100 characters
+                search_start = max(end - 100, start)
+                sentence_ends = []
+                
+                for punct in ['. ', '! ', '? ', '\n\n']:
+                    pos = text.rfind(punct, search_start, end)
+                    if pos > start:
+                        sentence_ends.append(pos + len(punct))
+                
+                if sentence_ends:
+                    end = max(sentence_ends)
+            
+            chunk = text[start:end].strip()
+            if chunk:
+                chunks.append(chunk)
+            
+            # Move start position with overlap
+            start = end - overlap
+            if start >= len(text):
+                break
+        
+        return chunks
+    
+    def get_session_stats(self, session_id: str) -> Dict[str, Any]:
+        """Get statistics about stored content for a session"""
+        try:
+            # Count PDF chunks
+            pdf_count = len(self.pdf_collection.get(
+                where={"session_id": session_id}
+            )['ids'])
+            
+            # Count lecture chunks
+            lecture_count = len(self.lecture_collection.get(
+                where={"session_id": session_id}
+            )['ids'])
+            
+            return {
+                'pdf_chunks': pdf_count,
+                'lecture_chunks': lecture_count,
+                'total_chunks': pdf_count + lecture_count
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to get session stats: {str(e)}")
+            return {
+                'pdf_chunks': 0,
+                'lecture_chunks': 0,
+                'total_chunks': 0
+            }
+    
+    def clear_session_data(self, session_id: str) -> bool:
+        """Clear all data for a specific session"""
+        try:
+            # Get all document IDs for this session
+            pdf_ids = self.pdf_collection.get(
+                where={"session_id": session_id}
+            )['ids']
+            
+            lecture_ids = self.lecture_collection.get(
+                where={"session_id": session_id}
+            )['ids']
+            
+            # Delete documents
+            if pdf_ids:
+                self.pdf_collection.delete(ids=pdf_ids)
+            
+            if lecture_ids:
+                self.lecture_collection.delete(ids=lecture_ids)
+            
+            logger.info(f"Cleared data for session {session_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to clear session data: {str(e)}")
+            return False

app/utils.py

@@ -0,0 +1,167 @@
+import os
+import logging
+import hashlib
+from typing import Dict, Any, Optional
+from datetime import datetime
+import json
+from dotenv import load_dotenv
+
+def setup_logging():
+    """Setup logging configuration"""
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.StreamHandler(),
+            logging.FileHandler('app.log')
+        ]
+    )
+
+def ensure_directory(path: str) -> bool:
+    """Ensure directory exists, create if it doesn't"""
+    try:
+        os.makedirs(path, exist_ok=True)
+        return True
+    except Exception as e:
+        logging.error(f"Failed to create directory {path}: {str(e)}")
+        return False
+
+def generate_file_hash(content: str) -> str:
+    """Generate SHA-256 hash for content"""
+    return hashlib.sha256(content.encode()).hexdigest()
+
+def sanitize_filename(filename: str) -> str:
+    """Sanitize filename for safe file system operations"""
+    import re
+    # Remove invalid characters
+    filename = re.sub(r'[<>:"/\\|?*]', '_', filename)
+    # Limit length
+    if len(filename) > 255:
+        name, ext = os.path.splitext(filename)
+        filename = name[:255-len(ext)] + ext
+    return filename
+
+def format_file_size(size_bytes: int) -> str:
+    """Format file size in human readable format"""
+    if size_bytes == 0:
+        return "0B"
+    
+    size_names = ["B", "KB", "MB", "GB", "TB"]
+    import math
+    i = int(math.floor(math.log(size_bytes, 1024)))
+    p = math.pow(1024, i)
+    s = round(size_bytes / p, 2)
+    return f"{s} {size_names[i]}"
+
+def validate_environment():
+    """Validate required environment variables"""
+    required_vars = ['OPENAI_API_KEY']
+    missing_vars = []
+    
+    for var in required_vars:
+        if not os.getenv(var):
+            missing_vars.append(var)
+    
+    if missing_vars:
+        logging.warning(f"Missing environment variables: {', '.join(missing_vars)}")
+        return False
+    
+    return True
+
+def save_json_file(data: Dict[Any, Any], filepath: str) -> bool:
+    """Save data to JSON file"""
+    try:
+        ensure_directory(os.path.dirname(filepath))
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        return True
+    except Exception as e:
+        logging.error(f"Failed to save JSON file {filepath}: {str(e)}")
+        return False
+
+def load_json_file(filepath: str) -> Optional[Dict[Any, Any]]:
+    """Load data from JSON file"""
+    try:
+        if not os.path.exists(filepath):
+            return None
+        
+        with open(filepath, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except Exception as e:
+        logging.error(f"Failed to load JSON file {filepath}: {str(e)}")
+        return None
+
+def cleanup_old_files(directory: str, max_age_hours: int = 24) -> int:
+    """Clean up old files in directory"""
+    try:
+        if not os.path.exists(directory):
+            return 0
+        
+        now = datetime.now()
+        removed_count = 0
+        
+        for filename in os.listdir(directory):
+            filepath = os.path.join(directory, filename)
+            
+            if os.path.isfile(filepath):
+                file_age = now - datetime.fromtimestamp(os.path.getmtime(filepath))
+                if file_age.total_seconds() > max_age_hours * 3600:
+                    try:
+                        os.remove(filepath)
+                        removed_count += 1
+                        logging.info(f"Removed old file: {filepath}")
+                    except Exception as e:
+                        logging.error(f"Failed to remove file {filepath}: {str(e)}")
+        
+        return removed_count
+        
+    except Exception as e:
+        logging.error(f"Failed to cleanup directory {directory}: {str(e)}")
+        return 0
+
+def get_system_info() -> Dict[str, Any]:
+    """Get basic system information"""
+    import platform
+    import psutil
+    
+    try:
+        return {
+            'platform': platform.system(),
+            'python_version': platform.python_version(),
+            'cpu_count': os.cpu_count(),
+            'memory_gb': round(psutil.virtual_memory().total / (1024**3), 2),
+            'disk_usage': {
+                'total_gb': round(psutil.disk_usage('/').total / (1024**3), 2),
+                'free_gb': round(psutil.disk_usage('/').free / (1024**3), 2)
+            }
+        }
+    except Exception as e:
+        logging.error(f"Failed to get system info: {str(e)}")
+        return {'error': str(e)}
+
+def measure_execution_time(func):
+    """Decorator to measure function execution time"""
+    import functools
+    import time
+    
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        execution_time = end_time - start_time
+        
+        logging.info(f"{func.__name__} executed in {execution_time:.2f} seconds")
+        return result
+    
+    return wrapper
+
+# Load environment variables
+load_dotenv()
+
+# Initialize logging when module is imported
+setup_logging()
+
+# Validate environment on import
+if not validate_environment():
+    logging.warning("Environment validation failed. Some features may not work properly.")

app/voice_synthesizer.py

@@ -0,0 +1,223 @@
+import openai
+import os
+import logging
+from typing import Dict, Any, Optional
+from pathlib import Path
+import tempfile
+import io
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+logger = logging.getLogger(__name__)
+
+class VoiceSynthesizer:
+    """Handles text-to-speech conversion for lecture content"""
+    
+    def __init__(self):
+        self.client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY", ""))
+        self.supported_voices = [
+            "alloy", "echo", "fable", "onyx", "nova", "shimmer"
+        ]
+        self.default_voice = "nova"
+    
+    def synthesize_lecture(self, lecture_content: str, voice: str = None, output_path: str = None) -> Dict[str, Any]:
+        """
+        Convert lecture text to speech using OpenAI TTS
+        
+        Args:
+            lecture_content: The lecture text to convert
+            voice: Voice to use (alloy, echo, fable, onyx, nova, shimmer)
+            output_path: Where to save the audio file
+        
+        Returns:
+            Dict with success status, file path, and metadata
+        """
+        try:
+            if not lecture_content.strip():
+                return {
+                    'success': False,
+                    'error': 'No content provided for synthesis',
+                    'file_path': None,
+                    'duration': 0
+                }
+            
+            # Validate and set voice
+            selected_voice = voice if voice in self.supported_voices else self.default_voice
+            
+            # Prepare content for TTS (remove markdown formatting)
+            clean_content = self._clean_content_for_tts(lecture_content)
+            
+            # Split content into chunks if too long (OpenAI TTS has limits)
+            chunks = self._split_content(clean_content, max_length=4000)
+            
+            if not output_path:
+                output_path = os.path.join("output", f"lecture_audio_{hash(lecture_content)}.mp3")
+            
+            # Ensure output directory exists
+            os.makedirs(os.path.dirname(output_path), exist_ok=True)
+            
+            if len(chunks) == 1:
+                # Single chunk - direct synthesis
+                response = self.client.audio.speech.create(
+                    model="tts-1",
+                    voice=selected_voice,
+                    input=chunks[0],
+                    response_format="mp3"
+                )
+                
+                # Save the audio file
+                with open(output_path, "wb") as f:
+                    f.write(response.content)
+                    
+            else:
+                # Multiple chunks - synthesize and combine
+                self._synthesize_multiple_chunks(chunks, selected_voice, output_path)
+            
+            # Get file size and estimate duration
+            file_size = os.path.getsize(output_path)
+            estimated_duration = self._estimate_audio_duration(clean_content)
+            
+            return {
+                'success': True,
+                'file_path': output_path,
+                'voice': selected_voice,
+                'duration': estimated_duration,
+                'file_size': file_size,
+                'chunks_count': len(chunks)
+            }
+            
+        except Exception as e:
+            logger.error(f"Voice synthesis failed: {str(e)}")
+            return {
+                'success': False,
+                'error': str(e),
+                'file_path': None,
+                'duration': 0
+            }
+    
+    def _clean_content_for_tts(self, content: str) -> str:
+        """Clean markdown and formatting for better TTS output"""
+        import re
+        
+        # Remove markdown headers
+        content = re.sub(r'^#{1,6}\s+', '', content, flags=re.MULTILINE)
+        
+        # Remove markdown emphasis
+        content = re.sub(r'\*\*(.*?)\*\*', r'\1', content)  # Bold
+        content = re.sub(r'\*(.*?)\*', r'\1', content)      # Italic
+        
+        # Remove markdown links
+        content = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', content)
+        
+        # Remove horizontal rules
+        content = re.sub(r'^---+$', '', content, flags=re.MULTILINE)
+        
+        # Clean up extra whitespace
+        content = re.sub(r'\n{3,}', '\n\n', content)
+        content = re.sub(r' {2,}', ' ', content)
+        
+        # Add pauses for better speech flow
+        content = re.sub(r'\n\n', '\n\n... \n\n', content)  # Longer pause between sections
+        
+        return content.strip()
+    
+    def _split_content(self, content: str, max_length: int = 4000) -> list:
+        """Split content into chunks suitable for TTS API"""
+        if len(content) <= max_length:
+            return [content]
+        
+        chunks = []
+        sentences = content.split('. ')
+        current_chunk = ""
+        
+        for sentence in sentences:
+            # Check if adding this sentence would exceed the limit
+            if len(current_chunk) + len(sentence) + 2 > max_length:
+                if current_chunk:
+                    chunks.append(current_chunk.strip())
+                    current_chunk = sentence + ". "
+                else:
+                    # Single sentence is too long, split by words
+                    words = sentence.split()
+                    word_chunk = ""
+                    for word in words:
+                        if len(word_chunk) + len(word) + 1 > max_length:
+                            if word_chunk:
+                                chunks.append(word_chunk.strip())
+                                word_chunk = word + " "
+                            else:
+                                # Single word is too long, truncate
+                                chunks.append(word[:max_length])
+                        else:
+                            word_chunk += word + " "
+                    if word_chunk:
+                        current_chunk = word_chunk + ". "
+            else:
+                current_chunk += sentence + ". "
+        
+        if current_chunk:
+            chunks.append(current_chunk.strip())
+        
+        return [chunk for chunk in chunks if chunk.strip()]
+    
+    def _synthesize_multiple_chunks(self, chunks: list, voice: str, output_path: str):
+        """Synthesize multiple chunks and combine them"""
+        import tempfile
+        import shutil
+        
+        temp_files = []
+        
+        try:
+            # Synthesize each chunk
+            for i, chunk in enumerate(chunks):
+                temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=f"_chunk_{i}.mp3")
+                temp_files.append(temp_file.name)
+                temp_file.close()
+                
+                response = self.client.audio.speech.create(
+                    model="tts-1",
+                    voice=voice,
+                    input=chunk,
+                    response_format="mp3"
+                )
+                
+                with open(temp_file.name, "wb") as f:
+                    f.write(response.content)
+            
+            # Combine audio files (simple concatenation for MP3)
+            with open(output_path, "wb") as outfile:
+                for temp_file in temp_files:
+                    with open(temp_file, "rb") as infile:
+                        shutil.copyfileobj(infile, outfile)
+            
+        finally:
+            # Clean up temporary files
+            for temp_file in temp_files:
+                try:
+                    os.unlink(temp_file)
+                except:
+                    pass
+    
+    def _estimate_audio_duration(self, content: str) -> int:
+        """Estimate audio duration in seconds based on content length"""
+        # Average speaking rate: ~150 words per minute
+        word_count = len(content.split())
+        duration_minutes = word_count / 150
+        return int(duration_minutes * 60)
+    
+    def get_available_voices(self) -> Dict[str, str]:
+        """Get list of available voices with descriptions"""
+        return {
+            "alloy": "Neutral, balanced voice",
+            "echo": "Crisp, clear voice",
+            "fable": "Warm, engaging voice",
+            "onyx": "Deep, authoritative voice",
+            "nova": "Pleasant, professional voice (default)",
+            "shimmer": "Bright, energetic voice"
+        }
+    
+    def validate_voice(self, voice: str) -> bool:
+        """Validate if the provided voice is supported"""
+        return voice in self.supported_voices

main.py

@@ -0,0 +1,18 @@
+import uvicorn
+import gradio as gr
+from app.gradio_interface import create_gradio_interface
+import os
+
+# Create output directory if it doesn't exist
+os.makedirs("output", exist_ok=True)
+
+# Create Gradio interface
+gradio_app = create_gradio_interface()
+
+if __name__ == "__main__":
+    gradio_app.launch(
+        server_name="0.0.0.0",
+        server_port=5000,
+        share=False,
+        show_error=True
+    )

requirements.txt

@@ -0,0 +1,14 @@
+chromadb>=1.0.12
+fastapi>=0.115.9
+gradio>=5.33.0
+langgraph>=0.4.8
+numpy>=2.3.0
+openai>=1.85.0
+pdfplumber>=0.11.6
+psutil>=7.0.0
+pypdf2>=3.0.1
+reportlab>=4.4.1
+uvicorn>=0.34.3
+pydantic
+typing-extensions
+python-dotenv

static/style.css

@@ -0,0 +1,264 @@
+/* Custom styles for AI Lecture Generator */
+
+:root {
+    --primary-color: #2c3e50;
+    --secondary-color: #3498db;
+    --success-color: #27ae60;
+    --warning-color: #f39c12;
+    --error-color: #e74c3c;
+    --background-color: #f8f9fa;
+    --text-color: #2c3e50;
+    --border-color: #ddd;
+}
+
+/* Global styles */
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background-color: var(--background-color);
+    color: var(--text-color);
+    line-height: 1.6;
+}
+
+/* Header styles */
+.gradio-container h1 {
+    color: var(--primary-color);
+    text-align: center;
+    margin-bottom: 2rem;
+    font-size: 2.5rem;
+    font-weight: bold;
+}
+
+/* Status boxes */
+.status-box {
+    padding: 15px;
+    border-radius: 8px;
+    margin: 15px 0;
+    font-weight: 500;
+    border-left: 4px solid;
+}
+
+.status-box.success {
+    background-color: #d4edda;
+    border-left-color: var(--success-color);
+    color: #155724;
+}
+
+.status-box.error {
+    background-color: #f8d7da;
+    border-left-color: var(--error-color);
+    color: #721c24;
+}
+
+.status-box.processing {
+    background-color: #d1ecf1;
+    border-left-color: var(--secondary-color);
+    color: #0c5460;
+}
+
+.status-box.warning {
+    background-color: #fff3cd;
+    border-left-color: var(--warning-color);
+    color: #856404;
+}
+
+/* Button styles */
+.gradio-button {
+    background: linear-gradient(135deg, var(--secondary-color), #2980b9);
+    color: white;
+    border: none;
+    padding: 12px 24px;
+    border-radius: 6px;
+    font-weight: 500;
+    transition: all 0.3s ease;
+    cursor: pointer;
+}
+
+.gradio-button:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 4px 12px rgba(52, 152, 219, 0.3);
+}
+
+.gradio-button.primary {
+    background: linear-gradient(135deg, var(--success-color), #229954);
+}
+
+.gradio-button.secondary {
+    background: linear-gradient(135deg, #95a5a6, #7f8c8d);
+}
+
+/* File upload area */
+.file-upload {
+    border: 2px dashed var(--border-color);
+    border-radius: 8px;
+    padding: 2rem;
+    text-align: center;
+    transition: all 0.3s ease;
+}
+
+.file-upload:hover {
+    border-color: var(--secondary-color);
+    background-color: #f0f8ff;
+}
+
+/* Input fields */
+.gradio-textbox,
+.gradio-dropdown {
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: 10px;
+    font-size: 14px;
+    transition: border-color 0.3s ease;
+}
+
+.gradio-textbox:focus,
+.gradio-dropdown:focus {
+    border-color: var(--secondary-color);
+    outline: none;
+    box-shadow: 0 0 0 3px rgba(52, 152, 219, 0.1);
+}
+
+/* Chat interface */
+.chatbot {
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    background: white;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+.chat-message {
+    padding: 12px;
+    margin: 8px;
+    border-radius: 8px;
+    max-width: 80%;
+}
+
+.chat-message.user {
+    background: var(--secondary-color);
+    color: white;
+    margin-left: auto;
+}
+
+.chat-message.assistant {
+    background: #f1f3f4;
+    color: var(--text-color);
+    margin-right: auto;
+}
+
+/* Tab styles */
+.gradio-tab {
+    border-bottom: 3px solid transparent;
+    padding: 12px 24px;
+    font-weight: 500;
+    transition: all 0.3s ease;
+}
+
+.gradio-tab.selected {
+    border-bottom-color: var(--secondary-color);
+    color: var(--secondary-color);
+}
+
+/* Card-like containers */
+.gradio-column {
+    background: white;
+    border-radius: 8px;
+    padding: 20px;
+    margin: 10px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+/* JSON display */
+.gradio-json {
+    background: #f8f9fa;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: 15px;
+    font-family: 'Courier New', monospace;
+    font-size: 13px;
+}
+
+/* Loading animation */
+.loading {
+    display: inline-block;
+    width: 20px;
+    height: 20px;
+    border: 3px solid #f3f3f3;
+    border-top: 3px solid var(--secondary-color);
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+    0% { transform: rotate(0deg); }
+    100% { transform: rotate(360deg); }
+}
+
+/* Progress bar */
+.progress-bar {
+    width: 100%;
+    height: 8px;
+    background-color: #f0f0f0;
+    border-radius: 4px;
+    overflow: hidden;
+}
+
+.progress-bar-fill {
+    height: 100%;
+    background: linear-gradient(90deg, var(--secondary-color), var(--success-color));
+    transition: width 0.3s ease;
+}
+
+/* Responsive design */
+@media (max-width: 768px) {
+    .gradio-container {
+        padding: 10px;
+    }
+    
+    .gradio-container h1 {
+        font-size: 2rem;
+    }
+    
+    .gradio-column {
+        margin: 5px;
+        padding: 15px;
+    }
+    
+    .chat-message {
+        max-width: 95%;
+    }
+}
+
+/* Accessibility improvements */
+.gradio-button:focus,
+.gradio-textbox:focus,
+.gradio-dropdown:focus {
+    outline: 2px solid var(--secondary-color);
+    outline-offset: 2px;
+}
+
+/* Dark mode support */
+@media (prefers-color-scheme: dark) {
+    :root {
+        --background-color: #1a1a1a;
+        --text-color: #ffffff;
+        --border-color: #404040;
+    }
+    
+    .gradio-column {
+        background: #2d2d2d;
+        color: var(--text-color);
+    }
+    
+    .gradio-json {
+        background: #2d2d2d;
+        color: var(--text-color);
+    }
+    
+    .chatbot {
+        background: #2d2d2d;
+    }
+    
+    .chat-message.assistant {
+        background: #404040;
+        color: var(--text-color);
+    }
+}