Update learning_platform.py

learning_platform.py

@@ -1,26 +1,85 @@
-
-import logging
 from typing import List, Dict, Any
 from dataclasses import dataclass, field
 from datetime import datetime
 import json
+import os
 from langchain.chat_models import ChatOpenAI
 from langchain.embeddings import OpenAIEmbeddings
 from langchain_community.vectorstores import FAISS
+import streamlit as st
+
+@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 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}
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+Ensure your response is helpful, easy to understand, and relevant to the course content.
+"""
 
 class CourseBuilder:
-    def __init__(self, api_key: str, agent_logs: list):
+    def __init__(self, api_key: str):
         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
+            openai_api_key=api_key
         )
         self.embeddings = OpenAIEmbeddings(openai_api_key=api_key)
         self.vector_store = FAISS.from_texts(
@@ -30,44 +89,25 @@ class CourseBuilder:
         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
-
+        response = await self.llm.apredict(prompt)
+        
+        # Debug: Log the raw response for troubleshooting
         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:
-            self.agent_logs.append(f"Raw response from API: {response}")
-
+            st.session_state.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["objectives"],
-                prerequisites=module_data.get("prerequisites", []),
+        modules = [
+            CourseModule(
+                title=module["title"],
+                objectives=module["objectives"],
+                prerequisites=module.get("prerequisites", []),
                 sections=[
                     Section(
                         title=section["title"],
@@ -75,10 +115,10 @@ class CourseBuilder:
                         key_points=section.get("key_points", []),
                         examples=section.get("examples", []),
                         quiz_questions=section.get("quiz_questions", [])
-                    ) for section in module_data.get("sections", [])
+                    ) for section in module.get("sections", [])
                 ]
-            )
-            modules.append(module)
+            ) for module in course_plan.get("modules", [])
+        ]
 
         learning_path = LearningPath(
             topic=topic,
@@ -95,38 +135,23 @@ class CourseBuilder:
             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
+        response = await self.llm.apredict(prompt)
 
         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
@@ -136,129 +161,51 @@ class CourseBuilder:
                 metadatas=[{"type": "module_content", "module": module.title}]
             )
 
-        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
+        response = await self.llm.apredict(prompt)
 
         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.
-"""
-
-@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 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)
+        self.course_builder = CourseBuilder(self.api_key)
 
     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}")
+            st.session_state.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)}")
+            st.session_state.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}")
+                st.session_state.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.")
+                st.session_state.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}")
+            st.session_state.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:
-            raise ValueError("Invalid module index")
+            raise ValueError("Invalid module index")