Update learning_platform.py

learning_platform.py

@@ -1,14 +1,20 @@
-import asyncio
-import json
+from typing import List, Dict, Any
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import List, Dict, Any, Literal
+import os
+import json
+import streamlit as st
+import openai
+import faiss
+from langchain import OpenAI
+from langgraph import Graph
+
 
-import faiss  # Example for vector store
-from langchain.chat_models import ChatOpenAI
-from langchain.embeddings import OpenAIEmbeddings  # Example for embeddings
-from langgraph.graph import StateGraph, END
+from langchain.prompts import PromptTemplate
 
+from langgraph.prebuilt import create_react_agent, ToolNode
+from langgraph.graph import END
+import asyncio
 
 @dataclass
 class Section:
@@ -18,7 +24,6 @@ class Section:
     quiz_questions: List[Dict[str, Any]] = field(default_factory=list)
     is_complete: bool = False
 
-
 @dataclass
 class LearningModule:
     title: str
@@ -29,7 +34,6 @@ class LearningModule:
     learning_objectives: List[str] = field(default_factory=list)
     is_complete: bool = False
 
-
 @dataclass
 class LearningPath:
     topic: str
@@ -39,7 +43,6 @@ class LearningPath:
     difficulty_level: str
     is_generating: bool = True
 
-
 @dataclass
 class CourseState:
     topic: str
@@ -49,25 +52,31 @@ class CourseState:
     sections: List[Dict] = field(default_factory=list)
     error: str = ""
 
-
 class Config:
     def __init__(self):
         self.llm_config = {
             "temperature": 0.7,
-            "model": "gpt-4o",  # Or another model if you don't have access to gpt-4o
+            "model": "gpt-4",
             "max_tokens": 2000
         }
-
+        
         self.graph_config = {
             "recursion_limit": 25,
             "max_retries": 3,
             "timeout": 300
         }
+        self.rag_config = {
+            "chunk_size": 500,
+            "chunk_overlap": 50,
+            "distance_metric": "cosine",
+            "k_similar": 3
+        }
         self.course_defaults = {
-            "max_modules": 5
+            "max_modules": 5,
+            "sections_per_module": 4,
+            "questions_per_quiz": 3
         }
 
-
 class CoursePrompts:
     @staticmethod
     def planning_prompt() -> str:
@@ -77,102 +86,84 @@ Structure:
 - Clear learning objectives
 - Practical applications
 Return JSON array of:
-{{
+{
     "title": "module title",
     "objectives": ["objective1", "objective2"],
     "prerequisites": ["prereq1", "prereq2"]
-}}"""
+}"""
 
     @staticmethod
     def content_prompt() -> str:
         return """Create engaging content for {module_title}:
-- Start with a hook
+- Start with hook
 - Include code examples
 - Real-world applications
 - Best practices
 Return JSON:
-{{
+{
     "content": "main content",
     "key_points": ["point1", "point2"],
-    "details": {{
+    "details": {
         "section1": "detailed content",
         "section2": "detailed content"
-    }}
-}}"""
+    }
+}"""
 
     @staticmethod
     def assessment_prompt() -> str:
-        return """Create an assessment for {module_title}.
+        return """Create assessment for {module_title}.
 Include:
 - Practical scenarios
 - Code challenges
 - Concept validation
-Return a JSON array of:
-{{
+Return JSON array of:
+{
     "question": "text",
     "options": ["A", "B", "C", "D"],
     "correct_answer": "A",
     "explanation": "detailed explanation"
-}}"""
-
+}"""
 
 class CourseBuilder:
-    def __init__(self, api_key=None, config: Config = None):
-        if api_key:
-            self.api_key = api_key
+    def __init__(self, api_key: str = None, config: Config = None):
+        # Debugging API Key
+        self.api_key = api_key or os.getenv('OPENAI_API_KEY')
+        if not self.api_key:
+            print("[DEBUG] API key is not set. Please ensure OPENAI_API_KEY is available in the environment.")
         else:
-            self.api_key = os.environ.get('OPENAI_API_KEY')
-            if not self.api_key:
-                print("[DEBUG] API key is not set. Please ensure OPENAI_API_KEY is available in the environment.")
-            else:
-                print(f"[DEBUG] Using API key: {self.api_key[:4]}... (truncated for security)")
+            print(f"[DEBUG] Using API key: {self.api_key[:4]}... (truncated for security)")
         self.config = config or Config()
-        self.llm = ChatOpenAI(model=self.config.llm_config["model"],
-                             temperature=self.config.llm_config["temperature"],
-                             max_tokens=self.config.llm_config["max_tokens"])
-
-        # Corrected instantiation of OpenAIEmbeddings
-        self.embeddings = OpenAIEmbeddings(openai_api_key=self.api_key)
-
-        # Example FAISS initialization for vector store (if needed)
-        self.vector_store = faiss.IndexFlatL2(128)
-        self.setup_graph()
-
-    def setup_graph(self):
-        workflow = StateGraph(CourseState)
-        workflow.add_node("plan_course", self.plan_course)
-        workflow.add_node("create_module", self.create_module)
-        workflow.add_node("generate_content", self.generate_content)
-        workflow.add_node("create_assessment", self.create_assessment)
-
-        workflow.add_edge("plan_course", "create_module")
-        workflow.add_conditional_edge("create_module", "generate_content", self.has_modules)  # Conditional edge
-        workflow.add_edge("generate_content", "create_assessment")
-        workflow.add_conditional_edge("create_assessment", "create_module", self.has_modules)  # Loop back
-        workflow.add_edge("create_assessment", END)  # Final end
-
-        self.graph = workflow.compile()
-
-    def has_modules(self, state: CourseState) -> Literal["generate_content", "create_module", "__end__"]:
-        if state.modules:
-            if state.current_module:
-                return "create_module"  # Go to next module
-            else:
-                return "generate_content"  # Start first module
-        else:
-            return END  # No more modules
+        self.llm = openai.Completion
+        # Debugging OpenAI Client Initialization
+        print(f"[DEBUG] Initializing ChatOpenAI with api_key: {self.api_key[:4]}... (truncated for security)")
+        self.embeddings = OpenAI.Embeddings(api_key=self.api_key)  # Example OpenAI Embeddings usage
+        # Debugging Embeddings Initialization
+        print(f"[DEBUG] Initializing OpenAIEmbeddings with api_key: {self.api_key[:4]}... (truncated for security)")
+        self.vector_store = faiss.IndexFlatL2(128)  # Example FAISS initialization for vector store
+        self.setup_agent()
+
+    def setup_agent(self):
+        # Define the tools to be used by the agent
+        tools = [self.plan_course, self.create_module, self.generate_content, self.create_assessment]
+        
+        # Create a react agent with the specified tools
+        self.graph = create_react_agent(self.llm, tools=tools)
 
     async def generate_with_retry(self, prompt: str, variables: Dict) -> Any:
+        # Debugging prompt generation
         print(f"[DEBUG] Generating text with prompt: {prompt.format(**variables)}")
         for attempt in range(self.config.graph_config["max_retries"]):
             try:
-                response = await self.llm.agenerate(
-                    [prompt.format(**variables)]
+                response = await asyncio.to_thread(
+                    openai.Completion.create,
+                    model=self.config.llm_config['model'],
+                    prompt=prompt.format(**variables),
+                    max_tokens=self.config.llm_config['max_tokens'],
+                    temperature=self.config.llm_config['temperature'],
+                    api_key=self.api_key
                 )
-                result = response.generations[0][0].text
+                result = response['choices'][0]['text']
                 return json.loads(result)
-            except json.JSONDecodeError as e:
-                print(f"[DEBUG] Invalid JSON received, retrying. Error: {e}")
             except Exception as e:
                 print(f"[DEBUG] Error occurred during attempt {attempt + 1}: {e}")
                 if attempt == self.config.graph_config["max_retries"] - 1:
@@ -222,7 +213,6 @@ class CourseBuilder:
             state.error = str(e)
             return state
 
-
 class LearningPlatform:
     def __init__(self, api_key: str = None, config: Config = None):
         self.config = config or Config()
@@ -230,32 +220,17 @@ class LearningPlatform:
 
     async def create_course(self, topic: str, difficulty: str) -> LearningPath:
         try:
-            state = CourseState(topic=topic, difficulty=difficulty)
-            result = await self.course_builder.graph.arun(
-                state,
-                config={"recursion_limit": self.config.graph_config["recursion_limit"]}
-            )
-
-            if result.error:
-                raise Exception(result.error)
-
-            modules = [
-                LearningModule(
-                    title=section["title"],
-                    content=section["content"]["content"],
-                    sections=[
-                        Section(
-                            title=kp,
-                            content=section["content"].get("details", {}).get(kp, ""),
-                            quiz_questions=section["assessment"]
-                        ) for kp in section["content"]["key_points"]
-                    ],
-                    prerequisites=section.get("prerequisites", []),
-                    learning_objectives=section.get("objectives", []),
-                    is_complete=True
-                ) for section in result.sections
-            ]
-
+            inputs = {"messages": ["user", f"Create a course on {topic} at {difficulty} level"]}
+            async for s in self.course_builder.graph.stream(inputs, stream_mode="values"):
+                message = s["messages"][-1]
+                if isinstance(message, tuple):
+                    print(message)
+                else:
+                    message.pretty_print()
+            
+            # Use the response to create LearningPath instance
+            # Placeholder logic - modify this to fit your needs
+            modules = [LearningModule(title="Sample Module", content="Generated content...")]
             return LearningPath(
                 topic=topic,
                 description=f"Course on {topic}",
@@ -265,5 +240,11 @@ class LearningPlatform:
                 is_generating=False
             )
         except Exception as e:
-            print(f"Course creation error: {str(e)}")  # Print to console for debugging
-            raise
+            st.error(f"Course creation error: {str(e)}")
+            raise,
+                difficulty_level=difficulty,
+                is_generating=False
+            )
+        except Exception as e:
+            st.error(f"Course creation error: {str(e)}")
+            raise