Update learning_platform.py

learning_platform.py

@@ -7,6 +7,10 @@ from langchain_community.chat_models import ChatOpenAI
 from langchain_community.embeddings import OpenAIEmbeddings
 from langchain_community.vectorstores import FAISS
 import streamlit as st
+import logging
+
+# Set up logging for debugging purposes
+logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 
 @dataclass
 class Section:
@@ -90,21 +94,25 @@ class CourseBuilder:
 
     async def plan_course(self, topic: str, difficulty: str) -> LearningPath:
         prompt = self.prompts.course_planning_prompt().format(topic=topic, difficulty=difficulty)
+        logging.debug(f"Sending course planning prompt: {prompt}")
         response = await self.llm.apredict(prompt)
+        logging.debug(f"Received response for course planning: {response}")
         
         # Debug: Log the raw response for troubleshooting
         if not response.strip():
+            logging.error("Empty response from API")
             raise ValueError("Empty response from API")
         
         try:
             course_plan = json.loads(response)
         except json.JSONDecodeError as e:
+            logging.error(f"Invalid JSON response from API: {str(e)}\nResponse: {response}")
             raise ValueError(f"Invalid JSON response from API: {str(e)}\nResponse: {response}")
 
         modules = [
             CourseModule(
                 title=module["title"],
-                objectives=module["objectives"],
+                objectives=module.get("objectives", []),
                 prerequisites=module.get("prerequisites", []),
                 sections=[
                     Section(
@@ -133,6 +141,7 @@ class CourseBuilder:
             metadatas=[{"type": "course_plan", "topic": topic}]
         )
 
+        logging.info(f"Created learning path for topic '{topic}' with difficulty '{difficulty}'")
         return learning_path
 
     async def create_module_content(self, module: CourseModule) -> List[Section]:
@@ -140,14 +149,18 @@ class CourseBuilder:
             title=module.title,
             objectives=", ".join(module.objectives)
         )
+        logging.debug(f"Sending module content prompt: {prompt}")
         response = await self.llm.apredict(prompt)
+        logging.debug(f"Received response for module content: {response}")
 
         if not response.strip():
+            logging.error("Empty response from API")
             raise ValueError("Empty response from API")
         
         try:
             content_json = json.loads(response)
         except json.JSONDecodeError as e:
+            logging.error(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", [])]
@@ -159,6 +172,7 @@ 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:
@@ -167,9 +181,12 @@ class CourseBuilder:
             module_title=module_title,
             question=question
         )
+        logging.debug(f"Sending user question prompt: {prompt}")
         response = await self.llm.apredict(prompt)
+        logging.debug(f"Received response for user question: {response}")
 
         if not response.strip():
+            logging.error("Empty response from API")
             raise ValueError("Empty response from API")
 
         return response
@@ -184,20 +201,25 @@ class LearningPlatform:
             learning_path = await self.course_builder.plan_course(topic, difficulty)
             return learning_path
         except Exception as e:
+            logging.error(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:
+                logging.info(f"Generating content for module: {module.title}")
                 sections = await self.course_builder.create_module_content(module)
                 module.sections = sections
                 module.is_complete = True
+                logging.info(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]
+            logging.info(f"Answering user question for module: {module.title}")
             answer = await self.course_builder.answer_user_question(path.topic, module.title, question)
             return answer
         else:
+            logging.error(f"Invalid module index: {module_index}")
             raise ValueError("Invalid module index")