Update learning_platform.py

learning_platform.py

@@ -1,10 +1,16 @@
-from dataclasses import dataclass, field
 from typing import List, Dict, Any, Optional
+from dataclasses import dataclass, field
 from datetime import datetime
 import asyncio
 import json
 import streamlit as st
-from openai import AsyncOpenAI
+from crewai import Agent, Task, Crew, Process
+from langchain.prompts import PromptTemplate
+from langchain.chains import SequentialChain, LLMChain
+from langchain.chat_models import ChatOpenAI
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.vectorstores import FAISS
+from langchain.text_splitter import RecursiveCharacterTextSplitter
 
 @dataclass
 class Section:
@@ -33,146 +39,172 @@ class LearningPath:
     difficulty_level: str
     is_generating: bool = True
 
-class LLMService:
+class CourseAgents:
     def __init__(self, api_key: str):
-        self.client = AsyncOpenAI(api_key=api_key)
-        self.model = "gpt-4o"
+        self.llm = ChatOpenAI(openai_api_key=api_key)
+        
+        self.curriculum_designer = Agent(
+            role="Curriculum Designer",
+            goal="Design comprehensive course structure",
+            backstory="Expert in educational design with focus on progressive learning",
+            tools=[self.llm],
+            verbose=True
+        )
         
-    async def generate(self, prompt: str, temperature: float = 1.0) -> str:
-    try:
-        st.write("🤖 Calling OpenAI API...")
-        response = await self.client.chat.completions.create(
-            model=self.model,
-            messages=[{"role": "system", "content": prompt}],
-            temperature=temperature
+        self.content_creator = Agent(
+            role="Content Creator",
+            goal="Create engaging, practical content",
+            backstory="Technical expert and educator",
+            tools=[self.llm],
+            verbose=True
+        )
+        
+        self.quiz_master = Agent(
+            role="Assessment Developer",
+            goal="Create effective learning assessments",
+            backstory="Expert in educational assessment",
+            tools=[self.llm],
+            verbose=True
         )
-        return response.choices[0].message.content
-    except Exception as e:
-        st.error(f"OpenAI API error: {str(e)}")
-        raise
 
 class ContentGenerator:
-    def __init__(self, llm_service: LLMService):
-        self.llm_service = llm_service
-
-    async def generate_section_content(self, topic: str, section_title: str) -> Section:
-        section = Section(title=section_title)
-        try:
-            content_prompt = f"""Create educational content for '{section_title}' in '{topic}' following this format exactly:
-{{
-    "content": "# {section_title}\\n\\n[Your markdown content here with examples, code snippets, and explanations]",
-    "key_points": [
-        "First key point",
-        "Second key point",
-        "Third key point"
-    ]
-}}
+    def __init__(self, api_key: str):
+        self.agents = CourseAgents(api_key)
+        self.llm = ChatOpenAI(openai_api_key=api_key)
+        self.setup_chains()
+        self.setup_rag()
 
-Content guidelines:
-- Use markdown formatting with headers (##)
-- Include 2-3 practical examples or code snippets
-- Provide best practices and common pitfalls depending on the topic. Focus on providing some aha moment or things to learn and tips. adjust based on the topic and context. 
-- Include diagrams and pictures where possible
-- Add expert tips and industry insights"""
+    def setup_chains(self):
+        self.structure_chain = LLMChain(
+            llm=self.llm,
+            prompt=PromptTemplate(
+                template="Create detailed structure for {topic} at {difficulty} level.",
+                input_variables=["topic", "difficulty"]
+            )
+        )
+        
+        self.content_chain = LLMChain(
+            llm=self.llm,
+            prompt=PromptTemplate(
+                template="Create content for {section_title} in {topic}.",
+                input_variables=["section_title", "topic"]
+            )
+        )
+        
+        self.quiz_chain = LLMChain(
+            llm=self.llm,
+            prompt=PromptTemplate(
+                template="Create assessment for {section_title} in {topic}.",
+                input_variables=["section_title", "topic"]
+            )
+        )
 
-            content_response = await self.llm_service.generate(content_prompt)
-            content_data = json.loads(content_response)
+    def setup_rag(self):
+        self.embeddings = OpenAIEmbeddings()
+        self.vector_store = FAISS.from_texts(
+            ["Initial knowledge base"],
+            embedding=self.embeddings
+        )
 
-            quiz_prompt = f"""Create quiz questions for '{section_title}' in '{topic}' following this format exactly:
-[{{
-    "question": "Write your question here",
-    "options": ["Option A", "Option B", "Option C", "Option D"],
-    "correct_answer": "Option A",
-    "explanation": "Explanation here",
-    "hint": "Optional hint here"
-}}]"""
+    async def generate_section_content(self, topic: str, section_title: str) -> Section:
+        try:
+            crew = Crew(
+                agents=[
+                    self.agents.content_creator,
+                    self.agents.quiz_master
+                ],
+                tasks=[
+                    Task(
+                        description=f"Create content for {section_title} in {topic}",
+                        agent=self.agents.content_creator
+                    ),
+                    Task(
+                        description=f"Create quiz for {section_title}",
+                        agent=self.agents.quiz_master
+                    )
+                ]
+            )
 
-            quiz_response = await self.llm_service.generate(quiz_prompt)
-            quiz_data = json.loads(quiz_response)
+            results = await crew.kickoff()
+            content_data = json.loads(results['content'])
+            quiz_data = json.loads(results['quiz'])
 
-            section.content = content_data["content"]
-            section.key_points = content_data["key_points"]
-            section.quiz_questions = quiz_data
-            section.is_complete = True
-            
-            return section
-        except json.JSONDecodeError as e:
-            st.error(f"JSON parsing error: {str(e)}\nResponse: {content_response}")
-            return section
+            return Section(
+                title=section_title,
+                content=content_data["content"],
+                key_points=content_data["key_points"],
+                quiz_questions=quiz_data,
+                is_complete=True
+            )
         except Exception as e:
-            st.error(f"Section creation error: {str(e)}")
-            return section
+            st.error(f"Section generation error: {str(e)}")
+            return Section(title=section_title)
 
 class LearningPlatform:
     def __init__(self, api_key: str):
-        self.llm_service = LLMService(api_key)
-        self.content_generator = ContentGenerator(self.llm_service)
+        self.content_generator = ContentGenerator(api_key)
+        self.agents = CourseAgents(api_key)
 
     async def create_course(self, topic: str, difficulty: str) -> LearningPath:
         try:
-            st.write("🔍 Generating course outline...")
-            titles_prompt = f"List 3 module titles for {topic} course. Return as JSON array of strings."
-            titles_task = asyncio.create_task(self.llm_service.generate(titles_prompt))
+            crew = Crew(
+                agents=[self.agents.curriculum_designer],
+                tasks=[
+                    Task(
+                        description=f"Design course structure for {topic} at {difficulty} level",
+                        agent=self.agents.curriculum_designer
+                    )
+                ]
+            )
+
+            structure = await crew.kickoff()
+            module_data = json.loads(structure['course_structure'])
             
-            try:
-                titles_response = await asyncio.wait_for(titles_task, timeout=30)
-                titles = json.loads(titles_response)
-            except asyncio.TimeoutError:
-                st.error("Timeout generating course outline")
-                raise
+            modules = [LearningModule(title=title) for title in module_data]
             
-            st.write("📚 Creating course structure...")
-            modules = [LearningModule(title=title) for title in titles]
             path = LearningPath(
                 topic=topic,
-                description=f"Course on {topic}",
+                description=module_data["description"],
                 modules=modules,
                 created_at=datetime.now(),
                 difficulty_level=difficulty
             )
             
-            st.write("🎯 Generating first module...")
-            try:
-                await asyncio.wait_for(
-                    self.create_module(path.modules[0], topic),
-                    timeout=60
-                )
-            except asyncio.TimeoutError:
-                st.error("Timeout generating first module")
-                raise
-            
-            st.write("✨ Starting background generation...")
+            await self.create_module(path.modules[0], topic)
             asyncio.create_task(self.generate_remaining_modules(path, topic))
             
             return path
             
         except Exception as e:
-            st.error(f"Course creation failed: {str(e)}")
+            st.error(f"Course creation error: {str(e)}")
             raise
 
-    async def create_module(self, module: LearningModule, topic: str, timeout: int = 30):
+    async def create_module(self, module: LearningModule, topic: str):
         try:
-            st.write(f"Generating sections for {module.title}...")
-            sections_prompt = f"List 3 section titles for module '{module.title}' in {topic}. Return JSON array."
+            crew = Crew(
+                agents=[self.agents.curriculum_designer],
+                tasks=[
+                    Task(
+                        description=f"Create sections for module {module.title}",
+                        agent=self.agents.curriculum_designer
+                    )
+                ]
+            )
             
-            section_titles = json.loads(await asyncio.wait_for(
-                self.llm_service.generate(sections_prompt),
-                timeout=timeout
-            ))
+            sections_data = await crew.kickoff()
+            section_titles = json.loads(sections_data['sections'])
             
             for title in section_titles:
-                st.write(f"Creating section: {title}")
                 section = await self.content_generator.generate_section_content(topic, title)
                 module.sections.append(section)
             
             module.is_complete = True
             return module
         except Exception as e:
-            st.error(f"Module generation failed: {str(e)}")
+            st.error(f"Module generation error: {str(e)}")
             raise
 
     async def generate_remaining_modules(self, path: LearningPath, topic: str):
-        for i, module in enumerate(path.modules[1:], 1):
-            st.write(f"Generating module {i+1} of {len(path.modules)}...")
+        for module in path.modules[1:]:
             await self.create_module(module, topic)
         path.is_generating = False