Update learning_platform.py

learning_platform.py

@@ -18,6 +18,7 @@ from langchain.agents.streaming import StreamingResponse
 # Data Models
 @dataclass
 class Section:
+    # Represents a section of a course module
     title: str
     content: str = ""
     key_points: List[str] = field(default_factory=list)
@@ -26,6 +27,7 @@ class Section:
 
 @dataclass
 class CourseModule:
+    # Represents a module in a course, which contains multiple sections
     title: str
     sections: List[Section] = field(default_factory=list)
     content: str = ""
@@ -35,6 +37,7 @@ class CourseModule:
 
 @dataclass
 class LearningPath:
+    # Represents the entire learning path consisting of multiple modules
     topic: str
     description: str
     modules: List[CourseModule]
@@ -44,6 +47,7 @@ class LearningPath:
 
 class Agents:
     def __init__(self, api_key: str):
+        # Initializes the agents responsible for content creation and editing
         self.content_creator = ChatOpenAI(
             temperature=0.7,
             model="gpt-4",
@@ -57,6 +61,7 @@ class Agents:
 
 class ContentGenerator:
     def __init__(self, api_key: str):
+        # Initializes the content generator with OpenAI embeddings and FAISS vector store
         self.embeddings = OpenAIEmbeddings(openai_api_key=api_key)
         self.vector_store = FAISS.from_texts(
             ["Initial empty store"],
@@ -64,9 +69,11 @@ class ContentGenerator:
         )
 
     def add_to_knowledge_base(self, content: str, metadata: Dict = None):
+        # Adds content to the knowledge base for future reference
         self.vector_store.add_texts([content], metadatas=[metadata or {}])
 
 class CourseState(TypedDict):
+    # Represents the current state of the course being generated
     messages: Annotated[Sequence[BaseMessage], add_messages]
     current_topic: str
     difficulty: str
@@ -76,6 +83,7 @@ class CourseState(TypedDict):
 class CoursePrompts:
     @staticmethod
     def planner_prompt() -> str:
+        # Prompt to create a course outline
         return """Create a course outline for {topic} at {difficulty} level.
         Return a strict JSON object:
         {{
@@ -90,6 +98,7 @@ class CoursePrompts:
 
     @staticmethod
     def section_prompt() -> str:
+        # Prompt to create a detailed section for a module
         return """Create a detailed section for {module_title} covering {topic}.
         Include:
         - Clear explanations
@@ -114,6 +123,7 @@ class CoursePrompts:
 
     @staticmethod
     def editor_prompt() -> str:
+        # Prompt to review and enhance a section of content
         return """Review and enhance the section:
         - Ensure clarity
         - Add examples
@@ -125,113 +135,128 @@ class CoursePrompts:
         Return in the same JSON format."""
 
 class CourseBuilder:
-   def __init__(self, api_key: str = None):
-       self.api_key = api_key or os.getenv("OPENAI_API_KEY")
-       self.setup_agents()
-       self.setup_graph()
-
-   def setup_agents(self):
-       self.llm = ChatOpenAI(
-           temperature=0.7,
-           model="gpt-4",
-           openai_api_key=self.api_key
-       )
-
-   def course_planner(self, state: CourseState) -> CourseState:
-       """Course planning agent node"""
-       print("---COURSE PLANNER---")
-       prompt = PromptTemplate(
-           template=CoursePrompts.planner_prompt(),
-           input_variables=["topic", "difficulty"]
-       )
-       
-       response = self.llm.predict(
-           prompt.format(
-               topic=state["current_topic"],
-               difficulty=state["difficulty"]
-           )
-       )
-       return {
-           "messages": [AIMessage(content=response)],
-           "status": "planning",
-           "current_topic": state["current_topic"],
-           "difficulty": state["difficulty"],
-           "modules": []
-       }
-
-   async def generate_module_content(self, module: CourseModule) -> List[Section]:
-       try:
-           section = Section(
-               title=f"Introduction to {module.title}",
-               content=f"Basic concepts of {module.title}",
-               key_points=["Key concept 1", "Key concept 2"],
-               quiz_questions=[{
-                   "question": f"What is {module.title}?",
-                   "options": ["A", "B", "C", "D"],
-                   "correct_answer": "A",
-                   "explanation": "Basic explanation"
-               }]
-           )
-           return [section]
-       except Exception as e:
-           print(f"Error generating content: {e}")
-           return []
-
-   def check_quality(self, state: CourseState) -> Literal["edit", "complete"]:
-       messages = state["messages"]
-       last_message = messages[-1]
-       
-       if len(last_message.content) > 1000 and "code example" in last_message.content.lower():
-           return "complete"
-       return "edit"
-
-   def setup_graph(self):
-       workflow = StateGraph(CourseState)
-       
-       workflow.add_node("planner", self.course_planner)
-       workflow.add_edge(START, "planner")
-       workflow.add_edge("planner", END)
-       
-       self.graph = workflow.compile()
-       
+    def __init__(self, api_key: str = None):
+        # Initializes the course builder with an API key and sets up the agents and graph
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        self.setup_agents()
+        self.setup_graph()
+
+    def setup_agents(self):
+        # Sets up the language model agent for generating content
+        self.llm = ChatOpenAI(
+            temperature=0.7,
+            model="gpt-4",
+            openai_api_key=self.api_key
+        )
+
+    def course_planner(self, state: CourseState) -> CourseState:
+        """Course planning agent node"""
+        print("---COURSE PLANNER---")
+        # Create a prompt to generate the course outline
+        prompt = PromptTemplate(
+            template=CoursePrompts.planner_prompt(),
+            input_variables=["topic", "difficulty"]
+        )
+        
+        # Use the language model to generate a response based on the prompt
+        response = self.llm.predict(
+            prompt.format(
+                topic=state["current_topic"],
+                difficulty=state["difficulty"]
+            )
+        )
+        # Return the updated state with the generated course plan
+        return {
+            "messages": [AIMessage(content=response)],
+            "status": "planning",
+            "current_topic": state["current_topic"],
+            "difficulty": state["difficulty"],
+            "modules": []
+        }
+
+    async def generate_module_content(self, module: CourseModule) -> List[Section]:
+        # Generates content for a module asynchronously
+        try:
+            section = Section(
+                title=f"Introduction to {module.title}",
+                content=f"Basic concepts of {module.title}",
+                key_points=["Key concept 1", "Key concept 2"],
+                quiz_questions=[{
+                    "question": f"What is {module.title}?",
+                    "options": ["A", "B", "C", "D"],
+                    "correct_answer": "A",
+                    "explanation": "Basic explanation"
+                }]
+            )
+            return [section]
+        except Exception as e:
+            # Log any errors that occur during content generation
+            print(f"Error generating content: {e}")
+            return []
+
+    def check_quality(self, state: CourseState) -> Literal["edit", "complete"]:
+        # Checks the quality of the generated content to determine if it needs editing or is complete
+        messages = state["messages"]
+        last_message = messages[-1]
+        
+        if len(last_message.content) > 1000 and "code example" in last_message.content.lower():
+            return "complete"
+        return "edit"
+
+    def setup_graph(self):
+        # Sets up the workflow graph for generating the course
+        workflow = StateGraph(CourseState)
+        
+        # Adds nodes and edges to the graph to define the workflow
+        workflow.add_node("planner", self.course_planner)
+        workflow.add_edge(START, "planner")
+        workflow.add_edge("planner", END)
+        
+        # Compiles the graph to create a runnable workflow
+        self.graph = workflow.compile()
+
 class LearningPlatform:
-   def __init__(self, api_key: str = None):
-       self.api_key = api_key or os.getenv("OPENAI_API_KEY")
-       self.course_builder = CourseBuilder(self.api_key)
-       self.agents = Agents(self.api_key)
-       self.content_generator = ContentGenerator(self.api_key)
-
-   async def create_course(self, topic: str, difficulty: str) -> LearningPath:
-       try:
-           initial_state = {
-               "messages": [HumanMessage(content=f"Create a course on {topic} at {difficulty} level")],
-               "current_topic": topic,
-               "difficulty": difficulty,
-               "modules": [],
-               "status": "planning"
-           }
-           
-           # Create initial module directly
-           module = CourseModule(
-               title=topic,
-               objectives=["Introduction to " + topic],
-               prerequisites=[]
-           )
-           module.sections = await self.course_builder.generate_module_content(module)
-           module.is_complete = True
-
-           return LearningPath(
-               topic=topic,
-               description=f"A {difficulty} level course on {topic}",
-               modules=[module],
-               created_at=datetime.now(),
-               difficulty_level=difficulty,
-               is_generating=False
-           )
-           
-       except Exception as e:
-           raise Exception(f"Course creation error: {str(e)}")
-           
+    def __init__(self, api_key: str = None):
+        # Initializes the learning platform with API key and sets up course builder, agents, and content generator
+        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
+        self.course_builder = CourseBuilder(self.api_key)
+        self.agents = Agents(self.api_key)
+        self.content_generator = ContentGenerator(self.api_key)
+
+    async def create_course(self, topic: str, difficulty: str) -> LearningPath:
+        try:
+            # Initial state for creating the course
+            initial_state = {
+                "messages": [HumanMessage(content=f"Create a course on {topic} at {difficulty} level")],
+                "current_topic": topic,
+                "difficulty": difficulty,
+                "modules": [],
+                "status": "planning"
+            }
+            
+            # Create initial module directly
+            module = CourseModule(
+                title=topic,
+                objectives=["Introduction to " + topic],
+                prerequisites=[]
+            )
+            # Generate content for the module asynchronously
+            module.sections = await self.course_builder.generate_module_content(module)
+            module.is_complete = True
+
+            # Return the learning path with the generated module
+            return LearningPath(
+                topic=topic,
+                description=f"A {difficulty} level course on {topic}",
+                modules=[module],
+                created_at=datetime.now(),
+                difficulty_level=difficulty,
+                is_generating=False
+            )
+            
+         except Exception as e:
+        raise Exception(f"Course creation error: {str(e)}")
+            
     async def generate_next_module(self, path: LearningPath, module_index: int):
         """Generate content for the next module asynchronously"""
         if module_index < len(path.modules):
@@ -244,3 +269,4 @@ class LearningPlatform:
                         section.content,
                         {"module": module.title, "section": section.title}
                     )
+