Update learning_platform.py

learning_platform.py

@@ -119,58 +119,73 @@ Return JSON:
 class CourseBuilder:
     def __init__(self, api_key: str):
         self.api_key = api_key
+        # Initialize RAG components
         self.embeddings = OpenAIEmbeddings(openai_api_key=api_key)
         self.vector_store = FAISS.from_texts(
             ["Initial course content"],
             embedding=self.embeddings
         )
+        # Initialize LLM
         self.llm = ChatOpenAI(
             temperature=0.7,
             model="gpt-4",
             openai_api_key=api_key
         )
         self.prompts = CoursePrompts()
-        self.setup_graph()  # Remove setup_tools() call
+        self.setup_graph()
 
-    def setup_graph(self):
-        """Set up the agent workflow graph"""
-        workflow = StateGraph(CourseState)
+    async def plan_course(self, state: CourseState) -> CourseState:
+        """Planner agent for course structure"""
+        st.session_state.agent_logs.append("📋 Planning course structure...")
         
-        # Add nodes for each agent role
-        workflow.add_node("planner", self.plan_course)
-        workflow.add_node("creator", self.create_content)
-        workflow.add_node("reviewer", self.review_content)
+        # Use RAG to find similar course structures
+        similar_courses = self.vector_store.similarity_search(
+            f"{state['topic']} {state['difficulty']} course",
+            k=2
+        )
+        context = "\n".join([doc.page_content for doc in similar_courses])
         
-        # Define edges and conditions
-        workflow.add_edge("planner", "creator")
-        workflow.add_conditional_edges(
-            "creator",
-            self.should_review,
-            {
-                "review": "reviewer",
-                "complete": END
-            }
+        prompt = self.prompts.course_planning_prompt()
+        response = await self.llm.apredict(
+            prompt.format(
+                topic=state["topic"],
+                difficulty=state["difficulty"],
+                context=context
+            )
         )
-        workflow.add_edge("reviewer", "creator")
         
-        self.graph = workflow.compile()
+        # Index the course plan for future reference
+        try:
+            course_plan = json.loads(response)
+            self.vector_store.add_texts(
+                [json.dumps(course_plan)],
+                metadatas=[{"type": "course_plan", "topic": state["topic"]}]
+            )
+        except Exception as e:
+            st.session_state.agent_logs.append(f"⚠️ Warning: Couldn't index course plan: {str(e)}")
+        
+        st.session_state.agent_logs.append("✅ Course structure planned")
+        return {
+            **state,
+            "messages": [AIMessage(content=response)],
+            "status": "planning_complete"
+        }
 
     async def create_content(self, state: CourseState) -> CourseState:
-        """Agent for creating module content using RAG"""
+        """Content creator agent using RAG"""
         st.session_state.agent_logs.append(f"📝 Creating module {state['current_module'] + 1}...")
         
         messages = state["messages"]
         current_plan = json.loads(messages[-1].content)
         current_module = current_plan["modules"][state["current_module"]]
         
-        # Use RAG to find similar content
+        # Use RAG for content enhancement
         similar_content = self.vector_store.similarity_search(
             current_module["title"],
-            k=3  # Get top 3 similar documents
+            k=3
         )
         context = "\n".join([doc.page_content for doc in similar_content])
         
-        # Generate enhanced content using RAG results
         prompt = self.prompts.module_content_prompt()
         content = await self.llm.apredict(
             prompt.format(
@@ -180,13 +195,16 @@ class CourseBuilder:
             )
         )
         
-        # Add new content to vector store for future RAG
+        # Index new content
         try:
             content_json = json.loads(content)
             for section in content_json.get("sections", []):
                 self.vector_store.add_texts(
                     [section["content"]],
-                    metadatas=[{"title": section["title"], "module": current_module["title"]}]
+                    metadatas=[{
+                        "type": "module_content",
+                        "module": current_module["title"]
+                    }]
                 )
         except Exception as e:
             st.session_state.agent_logs.append(f"⚠️ Warning: Couldn't index content: {str(e)}")
@@ -199,32 +217,24 @@ class CourseBuilder:
         }
 
     async def review_content(self, state: CourseState) -> CourseState:
-        """Agent for reviewing and improving content"""
+        """Content reviewer agent with RAG"""
         st.session_state.agent_logs.append("🔍 Reviewing content quality...")
         
         messages = state["messages"]
         content = messages[-1].content
         
-        # Use RAG to find similar content for comparison
-        try:
-            content_json = json.loads(content)
-            similar_contents = []
-            for section in content_json.get("sections", []):
-                similar = self.vector_store.similarity_search(
-                    section["content"],
-                    k=2
-                )
-                similar_contents.extend([doc.page_content for doc in similar])
-        except Exception as e:
-            similar_contents = []
-            st.session_state.agent_logs.append(f"⚠️ Warning: RAG search failed: {str(e)}")
-
-        # Review with context from RAG
+        # Use RAG for content review
+        similar_contents = self.vector_store.similarity_search(
+            content,
+            k=2
+        )
+        context = "\n".join([doc.page_content for doc in similar_contents])
+        
         prompt = self.prompts.review_prompt()
         review = await self.llm.apredict(
             prompt.format(
                 content=content,
-                similar_content="\n".join(similar_contents)
+                context=context
             )
         )
         
@@ -245,6 +255,35 @@ class CourseBuilder:
                 "status": "needs_revision"
             }
 
+    def should_review(self, state: CourseState) -> Literal["review", "complete"]:
+        """Decision node for content review"""
+        if "needs_review" in state["messages"][-1].content.lower():
+            return "review"
+        return "complete"
+
+    def setup_graph(self):
+        """Set up the agent workflow graph"""
+        workflow = StateGraph(CourseState)
+        
+        # Add agent nodes
+        workflow.add_node("planner", self.plan_course)
+        workflow.add_node("creator", self.create_content)
+        workflow.add_node("reviewer", self.review_content)
+        
+        # Define workflow
+        workflow.add_edge("planner", "creator")
+        workflow.add_conditional_edges(
+            "creator",
+            self.should_review,
+            {
+                "review": "reviewer",
+                "complete": END
+            }
+        )
+        workflow.add_edge("reviewer", "creator")
+        
+        self.graph = workflow.compile()
+        
 class LearningPlatform:
     def __init__(self, api_key: str = None):
         self.api_key = api_key or os.getenv("OPENAI_API_KEY")