Update app.py

app.py

@@ -1,294 +1,263 @@
-import streamlit as st
-import os
-from learning_platform import LearningPlatform, CourseBuilder
-import asyncio
-import nest_asyncio
+import logging
+from typing import List, Dict, Any
+from dataclasses import dataclass, field
 from datetime import datetime
-import sqlite3
-
-nest_asyncio.apply()
-
-# Page config
-st.set_page_config(page_title="MicroGuru", page_icon="🎓", layout="wide")
-
-# Custom CSS - Nice blue with white and pale orange scheme
-st.markdown("""
-<style>
-body {
-    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
-    color: #f0f8ff;
-    background-color: #1d3557;
-}
-.module-card {
-    padding: 20px;
-    background: #f1faee;
-    border-radius: 16px;
-    border: 1px solid #a8dadc;
-    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-    margin: 20px 0;
-}
-.quiz-card {
-    padding: 15px;
-    background: #f1faee;
-    border-radius: 12px;
-    border: 1px solid #a8dadc;
-    margin: 15px 0;
-}
-.progress-bar {
-    height: 20px;
-    background: #a8dadc;
-    border-radius: 12px;
-    overflow: hidden;
-}
-.progress-value {
-    height: 100%;
-    background: #457b9d;
-    transition: width 0.5s ease-in-out;
-}
-button[title="Previous Module"], button[title="Next Module"], button[title="Start Course"] {
-    background-color: #457b9d;
-    color: #f1faee;
-    border: none;
-    border-radius: 20px;
-    padding: 8px 16px;
-    margin: 10px 0;
-    font-size: 16px;
-    transition: background-color 0.3s ease;
-    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
-}
-button[title="Previous Module"]:hover, button[title="Next Module"]:hover, button[title="Start Course"]:hover {
-    background-color: #2b6cb0;
-    box-shadow: 0 6px 12px rgba(0, 0, 0, 0.15);
-}
-</style>
-""", unsafe_allow_html=True)
-
-# Initialize SQLite Database
-conn = sqlite3.connect('user_progress.db', check_same_thread=False)
-cursor = conn.cursor()
-cursor.execute('''CREATE TABLE IF NOT EXISTS progress (
-                user TEXT,
-                topic TEXT,
-                current_module INTEGER,
-                completion_date TEXT)''')
-conn.commit()
-
-# Initialize session state
-if 'learning_path' not in st.session_state:
-    st.session_state.learning_path = None
-if 'current_module' not in st.session_state:
-    st.session_state.current_module = 0
-if 'completed_courses' not in st.session_state:
-    st.session_state.completed_courses = []
-if 'user_progress' not in st.session_state:
-    st.session_state.user_progress = {}
-if 'agent_logs' not in st.session_state:
-    st.session_state.agent_logs = []
-
-# Initialize platform
-api_key = os.environ.get('OPENAI_API_KEY')
-if not api_key:
-    st.error("⚠️ OpenAI API key not found.")
-    st.stop()
-platform = LearningPlatform(api_key)
-
-def display_course_summary(path):
-    """Display course summary and start button"""
-    st.markdown(f"### 🎓 {path.topic}")
-    st.write(path.description)
-    
-    st.markdown("#### 📚 Learning Objectives")
-    for module in path.modules:
-        st.markdown(f"- **{module.title}**")
-        for obj in module.objectives:
-            st.write(f"  - {obj}")
-    
-    if st.button("Start Course 🚀"):
-        st.session_state.learning_path = path
-        st.session_state.current_module = 0
-        st.experimental_rerun()
-
-def display_progress_bar():
-    """Display course progress bar"""
-    if st.session_state.learning_path:
-        path = st.session_state.learning_path
-        total_modules = len(path.modules)
-        
-        if total_modules > 0:
-            current = st.session_state.current_module + 1
-            progress = (current / total_modules) * 100
-            
-            st.markdown(f"""
-            <div class="progress-bar">
-                <div class="progress-value" style="width: {progress}%"></div>
-            </div>
-            <p style="text-align: center; font-weight: 500; color: #f1faee;">Module {current}/{total_modules}</p>
-            """, unsafe_allow_html=True)
+import json
+from langchain.chat_models import ChatOpenAI
+from langchain.embeddings import OpenAIEmbeddings
+from langchain_community.vectorstores import FAISS
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+
+@dataclass
+class Section:
+    title: str
+    content: str = ""
+    key_points: List[str] = field(default_factory=list)
+    examples: List[str] = field(default_factory=list)
+    quiz_questions: List[Dict[str, Any]] = field(default_factory=list)
+    is_complete: bool = False
+
+@dataclass
+class CourseModule:
+    title: str
+    objectives: List[str]
+    prerequisites: List[str] = field(default_factory=list)
+    sections: List[Section] = field(default_factory=list)
+    is_complete: bool = False
+
+@dataclass
+class LearningPath:
+    topic: str
+    description: str
+    modules: List[CourseModule]
+    difficulty_level: str
+    created_at: datetime
+    is_generating: bool = True
+
+class CourseBuilder:
+    def __init__(self, api_key: str, agent_logs: list):
+        self.api_key = api_key
+        self.agent_logs = agent_logs
+        self.llm = ChatOpenAI(
+            temperature=0.7,
+            model="gpt-4",
+            openai_api_key=api_key,
+            max_retries=3,
+            retry_on_timeout=True,
+            timeout=60
+        )
+        self.embeddings = OpenAIEmbeddings(openai_api_key=api_key)
+        self.vector_store = FAISS.from_texts(
+            ["Initial course content"],
+            embedding=self.embeddings
+        )
+        self.prompts = CoursePrompts()
+
+    async def plan_course(self, topic: str, difficulty: str) -> LearningPath:
+        logging.info(f"Planning course for topic: {topic}, difficulty: {difficulty}")
+        prompt = self.prompts.course_planning_prompt().format(topic=topic, difficulty=difficulty)
+        logging.info(f"Sending prompt: {prompt}")
+
+        try:
+            response = await self.llm.apredict(prompt)
+            logging.info(f"Received response: {response}")
+        except Exception as e:
+            logging.error(f"Error getting response from API: {str(e)}")
+            self.agent_logs.append(f"Error getting response from API: {str(e)}")
+            raise e
+
+        if not response.strip():
+            logging.error("Empty response from API")
+            self.agent_logs.append("Empty response from API")
+            raise ValueError("Empty response from API")
         else:
-            st.info("No modules available yet. Please create a new course.")
-
-def display_module_content(module):
-    """Display module content and quiz"""
-    st.markdown(f"""
-    <div class="module-card">
-        <h3 style="color: #1d3557;">{module.title}</h3>
-    """, unsafe_allow_html=True)
-    
-    # Display objectives
-    st.subheader("Learning Objectives")
-    for obj in module.objectives:
-        st.write(f"- {obj}")
-    
-    # Display prerequisites if any
-    if module.prerequisites:
-        st.subheader("Prerequisites")
-        for prereq in module.prerequisites:
-            st.write(f"- {prereq}")
-    
-    if not module.is_complete:
-        st.info("🔄 Content is being generated...")
-        return
-    
-    # Display sections
-    for section in module.sections:
-        st.subheader(section.title)
-        st.write(section.content)
-        
-        st.subheader("Key Points")
-        for point in section.key_points:
-            st.write(f"- {point}")
-        
-        if section.examples:
-            st.subheader("Examples")
-            for example in section.examples:
-                st.code(example)
-        
-        # Quiz section
-        st.subheader("Knowledge Check")
-        for i, question in enumerate(section.quiz_questions):
-            st.write(f"**Q{i+1}: {question['question']}**")
-            answer = st.radio(
-                "Choose your answer:",
-                question['options'],
-                key=f"quiz_{section.title}_{i}"
+            self.agent_logs.append(f"Raw response from API: {response}")
+
+        try:
+            course_plan = json.loads(response)
+            logging.info(f"Parsed course plan: {course_plan}")
+        except json.JSONDecodeError as e:
+            logging.error(f"Invalid JSON response from API: {str(e)}\nResponse: {response}")
+            self.agent_logs.append(f"Invalid JSON response from API: {str(e)}\nResponse: {response}")
+            raise ValueError(f"Invalid JSON response from API: {str(e)}\nResponse: {response}")
+
+        modules = []
+        for module_data in course_plan.get("modules", []):
+            if "title" not in module_data:
+                logging.error(f"Missing 'title' field in module: {module_data}")
+                self.agent_logs.append(f"Missing 'title' field in module: {module_data}")
+                raise ValueError("Invalid module data: missing 'title' field")
+
+            module = CourseModule(
+                title=module_data["title"],
+                objectives=module_data.get("objectives", []),
+                prerequisites=module_data.get("prerequisites", []),
+                sections=[
+                    Section(
+                        title=section["title"],
+                        content=section.get("content", ""),
+                        key_points=section.get("key_points", []),
+                        examples=section.get("examples", []),
+                        quiz_questions=section.get("quiz_questions", [])
+                    ) for section in module_data.get("sections", [])
+                ]
+            )
+            modules.append(module)
+
+        learning_path = LearningPath(
+            topic=topic,
+            description=course_plan.get("description", ""),
+            modules=modules,
+            difficulty_level=difficulty,
+            created_at=datetime.now(),
+            is_generating=False
+        )
+
+        # Store embeddings for course plan for future reference
+        self.vector_store.add_texts(
+            [json.dumps(course_plan)],
+            metadatas=[{"type": "course_plan", "topic": topic}]
+        )
+
+        logging.info(f"Created learning path: {learning_path}")
+        return learning_path
+
+    async def create_module_content(self, module: CourseModule) -> List[Section]:
+        logging.info(f"Creating content for module: {module.title}")
+        prompt = self.prompts.module_content_prompt().format(
+            title=module.title,
+            objectives=", ".join(module.objectives)
+        )
+        logging.info(f"Sending prompt: {prompt}")
+
+        try:
+            response = await self.llm.apredict(prompt)
+            logging.info(f"Received response: {response}")
+        except Exception as e:
+            logging.error(f"Error getting response from API: {str(e)}")
+            self.agent_logs.append(f"Error getting response from API: {str(e)}")
+            raise e
+
+        if not response.strip():
+            logging.error("Empty response from API")
+            self.agent_logs.append("Empty response from API")
+            raise ValueError("Empty response from API")
+
+        try:
+            content_json = json.loads(response)
+            logging.info(f"Parsed module content: {content_json}")
+        except json.JSONDecodeError as e:
+            logging.error(f"Invalid JSON response from API: {str(e)}\nResponse: {response}")
+            self.agent_logs.append(f"Invalid JSON response from API: {str(e)}\nResponse: {response}")
+            raise ValueError(f"Invalid JSON response from API: {str(e)}\nResponse: {response}")
+
+        sections = [Section(**section) for section in content_json.get("sections", [])]
+
+        # Store embeddings for module content
+        for section in sections:
+            self.vector_store.add_texts(
+                [section.content],
+                metadatas=[{"type": "module_content", "module": module.title}]
             )
-            
-            if st.button("Check Answer", key=f"check_{section.title}_{i}"):
-                if answer == question['correct_answer']:
-                    st.success(f"✅ Correct! {question['explanation']}")
-                    st.session_state.user_progress[section.title] = st.session_state.user_progress.get(section.title, 0) + 1
-                else:
-                    st.error(f"❌ Incorrect. {question['explanation']}")
-
-def create_new_course():
-    """Handle new course creation"""
-    st.markdown("### 🚀 Start Your Learning Journey")
-    
-    topic = st.text_input("What would you like to learn?")
-    difficulty = st.select_slider(
-        "Choose difficulty level:",
-        options=["beginner", "intermediate", "advanced"],
-        value="intermediate"
-    )
-    
-    if st.button("Create Course 🎯"):
-        with st.spinner('Our AI agents are crafting your personalized course...'):
-            try:
-                async def create_course():
-                    return await platform.create_course(topic, difficulty)
-                
-                path = asyncio.run(create_course())
-                display_course_summary(path)
-            except Exception as e:
-                st.session_state.agent_logs.append(f"Error: {str(e)}")
-                st.error(f"Error: {str(e)}")
-
-def main():
-    st.title("🎓 MicroGuru")
-    
-    # Navigation
-    pages = {
-        "🏠 Home": create_new_course,
-        "📚 Current Course": lambda: display_current_course(),
-        "🏆 Completed Courses": lambda: display_completed_courses()
-    }
-    
-    page = st.sidebar.radio("Navigation", list(pages.keys()))
-    
-    if page == "📚 Current Course" and not st.session_state.learning_path:
-        st.info("👋 Welcome! Start by creating a new course from the Home page.")
-        page = "🏠 Home"
-    
-    pages[page]()
-
-def display_current_course():
-    """Display current course content"""
-    path = st.session_state.learning_path
-    if not path:
-        st.info("👋 Welcome! Start by creating a new course from the Home page.")
-        return
-
-    display_progress_bar()
-    
-    col1, col2 = st.columns([7, 3])
-    
-    with col1:
-        current_module = path.modules[st.session_state.current_module]
-        display_module_content(current_module)
-    
-    with col2:
-        st.markdown("### 📌 Navigation")
-        
-        # Previous module button
-        if st.session_state.current_module > 0:
-            if st.button("⬅️ Previous Module", key="prev_module"):
-                st.session_state.current_module -= 1
-                save_progress(path, st.session_state.current_module)
-                st.experimental_rerun()
-        
-        # Next module button
-        next_idx = st.session_state.current_module + 1
-        if next_idx < len(path.modules):
-            if path.modules[next_idx].is_complete:
-                if st.button("Next Module ➡️", key="next_module"):
-                    st.session_state.current_module = next_idx
-                    save_progress(path, st.session_state.current_module)
-                    st.experimental_rerun()
-            else:
-                with st.spinner("Generating next module as we speak..."):
-                    asyncio.run(
-                        platform.generate_next_module(path, next_idx)
-                    )
-                st.experimental_rerun()
+
+        logging.info(f"Created {len(sections)} sections for module: {module.title}")
+        return sections
+
+    async def answer_user_question(self, topic: str, module_title: str, question: str) -> str:
+        logging.info(f"Answering user question for topic: {topic}, module: {module_title}, question: {question}")
+        prompt = self.prompts.user_question_prompt().format(
+            topic=topic,
+            module_title=module_title,
+            question=question
+        )
+        logging.info(f"Sending prompt: {prompt}")
+
+        try:
+            response = await self.llm.apredict(prompt)
+            logging.info(f"Received response: {response}")
+        except Exception as e:
+            logging.error(f"Error getting response from API: {str(e)}")
+            self.agent_logs.append(f"Error getting response from API: {str(e)}")
+            raise e
+
+        if not response.strip():
+            logging.error("Empty response from API")
+            self.agent_logs.append("Empty response from API")
+            raise ValueError("Empty response from API")
+
+        return response
+
+class CoursePrompts:
+    @staticmethod
+    def course_planning_prompt() -> str:
+        return """As a course planning expert, design a structured learning path for {topic} at {difficulty} level.
+
+Requirements:
+1. 5-7 progressive modules
+2. Clear prerequisites and objectives
+3. Practical applications
+4. Real-world examples
+5. A compelling description that excites the learner about the journey ahead
+6. Each module should contain content, quiz questions, and be designed to progressively enhance understanding.
+Return a structured JSON with detailed content for each module.
+"""
+
+    @staticmethod
+    def module_content_prompt() -> str:
+        return """Create engaging module content for the module titled '{title}' with the following objectives:
+
+Objectives: {objectives}
+
+Include:
+1. Clear explanations with practical examples to deepen understanding
+2. Real-world applications relevant to the topic
+3. Key points that summarize each section concisely
+4. A set of 3-5 quiz questions for each section, with answers and explanations
+5. Encourage learners to think critically and ask questions related to '{title}'
+Return a structured JSON with detailed content for each section.
+"""
+
+    @staticmethod
+    def user_question_prompt() -> str:
+        return """As an AI assistant, provide a clear and informative answer to the user's question based on the course topic '{topic}', the module '{module_title}', and the related content.
+
+User Question: {question}
+
+Ensure your response is helpful, easy to understand, and relevant to the course content.
+"""
+
+class LearningPlatform:
+    def __init__(self, api_key: str = None):
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        self.agent_logs = []
+        self.course_builder = CourseBuilder(self.api_key, self.agent_logs)
+
+    async def create_course(self, topic: str, difficulty: str) -> LearningPath:
+        try:
+            learning_path = await self.course_builder.plan_course(topic, difficulty)
+            # Log successful course creation
+            self.agent_logs.append(f"Successfully created course: {learning_path.topic}")
+            return learning_path
+        except Exception as e:
+            self.agent_logs.append(f"Course creation error: {str(e)}")
+            raise Exception(f"Course creation error: {str(e)}")
+
+    async def generate_next_module(self, path: LearningPath, module_index: int):
+        if module_index < len(path.modules):
+            module = path.modules[module_index]
+            if not module.is_complete:
+                self.agent_logs.append(f"Generating content for module: {module.title}")
+                sections = await self.course_builder.create_module_content(module)
+                module.sections = sections
+                module.is_complete = True
+                self.agent_logs.append(f"Module '{module.title}' is now complete.")
+
+    async def handle_user_question(self, path: LearningPath, module_index: int, question: str) -> str:
+        if module_index < len(path.modules):
+            module = path.modules[module_index]
+            self.agent_logs.append(f"Answering user question for module: {module.title}")
+            answer = await self.course_builder.answer_user_question(path.topic, module.title, question)
+            return answer
         else:
-            st.success("🎉 You have completed all modules!")
-            if path not in st.session_state.completed_courses:
-                path.completion_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                st.session_state.completed_courses.append(path)
-                save_progress(path, len(path.modules))
-
-def display_completed_courses():
-    """Display completed courses"""
-    st.markdown("### 🏆 Completed Courses")
-    
-    if not st.session_state.completed_courses:
-        st.info("Complete your first course to see it here!")
-        return
-    
-    for course in st.session_state.completed_courses:
-        st.markdown(f"""
-        <div class="module-card">
-            <h4 style="color: #1d3557;">{course.topic}</h4>
-            <p style="color: #f1faee;">{course.description}</p>
-            <p><small style="color: #a8dadc;">Completed on: {course.completion_date}</small></p>
-        </div>
-        """, unsafe_allow_html=True)
-
-def save_progress(path, current_module):
-    """Save user progress to SQLite database"""
-    cursor.execute('''INSERT OR REPLACE INTO progress (user, topic, current_module, completion_date) VALUES (?, ?, ?, ?)''',
-                   ('user1', path.topic, current_module, None))
-    conn.commit()
-
-if __name__ == "__main__":
-    main()
+            raise ValueError("Invalid module index")