Create utils/langgraph_conversation.py

utils/langgraph_conversation.py

@@ -0,0 +1,164 @@
+# utils/langgraph_conversation.py
+
+from langgraph.graph import StateGraph, END
+from langchain.memory import ConversationBufferMemory
+from langchain.prompts import ChatPromptTemplate
+from langchain.chat_models import ChatAnthropic
+from langchain.schema import HumanMessage, AIMessage
+import streamlit as st
+
+class ConversationalLearningGraph:
+    def __init__(self, anthropic_api_key):
+        self.llm = ChatAnthropic(anthropic_api_key=anthropic_api_key)
+        self.memory = ConversationBufferMemory(
+            memory_key="chat_history",
+            return_messages=True
+        )
+        self.graph = self._create_graph()
+
+    def _create_graph(self):
+        # Create the graph
+        workflow = StateGraph(StateGraph.from_empty())
+
+        # Add nodes for different conversation stages
+        workflow.add_node("understand_question", self._understand_question)
+        workflow.add_node("check_prerequisites", self._check_prerequisites)
+        workflow.add_node("generate_response", self._generate_response)
+        workflow.add_node("suggest_next_topics", self._suggest_next_topics)
+
+        # Define the edges
+        workflow.add_edge("understand_question", "check_prerequisites")
+        workflow.add_edge("check_prerequisites", "generate_response")
+        workflow.add_edge("generate_response", "suggest_next_topics")
+        workflow.add_edge("suggest_next_topics", END)
+
+        # Add conditional edges
+        workflow.add_conditional_edges(
+            "check_prerequisites",
+            self._needs_prerequisites,
+            {
+                True: "understand_question",  # Loop back if prerequisites needed
+                False: "generate_response"    # Continue if prerequisites met
+            }
+        )
+
+        return workflow.compile()
+
+    async def _understand_question(self, state):
+        """Analyze and categorize the question"""
+        question = state['question']
+        
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", "You are an expert at understanding trading questions."),
+            ("human", "Analyze this trading question: {question}")
+        ])
+
+        response = await self.llm.ainvoke(prompt.format_messages(question=question))
+        
+        return {
+            **state,
+            "question_analysis": response.content,
+            "category": self._categorize_question(response.content)
+        }
+
+    def _check_prerequisites(self, state):
+        """Check if user needs prerequisite knowledge"""
+        history = self.memory.chat_memory.messages
+        return {
+            **state,
+            "needs_prerequisites": self._evaluate_prerequisites(
+                state['category'],
+                history
+            )
+        }
+
+    async def _generate_response(self, state):
+        """Generate a detailed response"""
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", "You are an expert trading educator."),
+            ("human", """Given this trading question and context:
+            Question: {question}
+            Category: {category}
+            Previous discussion: {history}
+            
+            Provide a detailed, educational response.""")
+        ])
+
+        response = await self.llm.ainvoke(
+            prompt.format_messages(
+                question=state['question'],
+                category=state['category'],
+                history=self.memory.chat_memory.messages
+            )
+        )
+
+        return {
+            **state,
+            "response": response.content
+        }
+
+    async def _suggest_next_topics(self, state):
+        """Suggest related topics to explore"""
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", "Suggest related trading topics to explore next."),
+            ("human", """Based on:
+            Current topic: {question}
+            Response given: {response}
+            
+            Suggest 3 related topics to explore next.""")
+        ])
+
+        suggestions = await self.llm.ainvoke(
+            prompt.format_messages(
+                question=state['question'],
+                response=state['response']
+            )
+        )
+
+        return {
+            **state,
+            "next_topics": suggestions.content
+        }
+
+    def _needs_prerequisites(self, state):
+        """Determine if prerequisites are needed"""
+        return state.get('needs_prerequisites', False)
+
+    def _categorize_question(self, analysis):
+        """Categorize the question type"""
+        categories = [
+            "basic_concepts",
+            "technical_analysis",
+            "risk_management",
+            "trading_strategy",
+            "market_mechanics"
+        ]
+        # Implement categorization logic
+        return "basic_concepts"  # Placeholder
+
+    def _evaluate_prerequisites(self, category, history):
+        """Evaluate if user needs prerequisites"""
+        # Implement prerequisite checking logic
+        return False  # Placeholder
+
+    async def process_question(self, question):
+        """Process a question through the conversation graph"""
+        # Add question to memory
+        self.memory.chat_memory.add_user_message(question)
+
+        # Initialize state
+        initial_state = {
+            "question": question,
+            "memory": self.memory
+        }
+
+        # Run the graph
+        final_state = await self.graph.arun(initial_state)
+
+        # Add response to memory
+        self.memory.chat_memory.add_ai_message(final_state['response'])
+
+        return {
+            'response': final_state['response'],
+            'next_topics': final_state['next_topics']
+        }