context fixes

multi_llm_chatbot_backend/app/core/improved_orchestrator.py

@@ -0,0 +1,317 @@
+from typing import Dict, List, Optional, Any
+from app.models.persona import Persona
+from app.core.session_manager import ConversationContext, get_session_manager
+from app.core.context_manager import get_context_manager
+from app.llm.llm_client import LLMClient
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+class ImprovedChatOrchestrator:
+    """
+    Improved orchestrator with proper session management and context handling
+    """
+    
+    def __init__(self):
+        self.personas: Dict[str, Persona] = {}
+        self.session_manager = get_session_manager()
+        self.context_manager = get_context_manager()
+    
+    def register_persona(self, persona: Persona):
+        """Register a persona with the orchestrator"""
+        self.personas[persona.id] = persona
+        logger.info(f"Registered persona: {persona.id} ({persona.name})")
+    
+    def get_persona(self, persona_id: str) -> Optional[Persona]:
+        """Get a specific persona"""
+        return self.personas.get(persona_id)
+    
+    def list_personas(self) -> List[str]:
+        """List all available persona IDs"""
+        return list(self.personas.keys())
+    
+    async def process_message(self, 
+                            user_input: str, 
+                            session_id: Optional[str] = None,
+                            response_length: str = "medium") -> Dict[str, Any]:
+        """
+        Process a user message through the orchestration pipeline
+        """
+        try:
+            # Get or create session
+            session = self.session_manager.get_session(session_id)
+            
+            # Add user message to session
+            session.append_message("user", user_input)
+            
+            # Determine if we need clarification
+            needs_clarification = self._needs_clarification(session, user_input)
+            
+            if needs_clarification:
+                # Generate clarification question
+                clarification = await self._generate_clarification_question(session)
+                session.append_message("orchestrator", clarification)
+                
+                return {
+                    "type": "clarification",
+                    "session_id": session.session_id,
+                    "message": clarification,
+                    "context_summary": self.context_manager.get_context_summary(session.messages)
+                }
+            
+            # Generate responses from all personas
+            responses = await self._generate_persona_responses(session, response_length)
+            
+            return {
+                "type": "persona_responses",
+                "session_id": session.session_id,
+                "responses": responses,
+                "context_summary": self.context_manager.get_context_summary(session.messages)
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in process_message: {str(e)}")
+            return {
+                "type": "error",
+                "session_id": session_id,
+                "message": "I encountered an error processing your request. Please try again.",
+                "error": str(e)
+            }
+    
+    async def chat_with_persona(self, 
+                               user_input: str, 
+                               persona_id: str,
+                               session_id: Optional[str] = None,
+                               response_length: str = "medium") -> Dict[str, Any]:
+        """
+        Chat with a specific persona
+        """
+        try:
+            if persona_id not in self.personas:
+                return {
+                    "type": "error",
+                    "message": f"Persona '{persona_id}' not found"
+                }
+            
+            # Get or create session
+            session = self.session_manager.get_session(session_id)
+            
+            # Add user message
+            session.append_message("user", user_input)
+            
+            # Generate response from specific persona
+            persona = self.personas[persona_id]
+            response = await self._generate_single_persona_response(session, persona, response_length)
+            
+            # Add persona response to session
+            session.append_message(persona_id, response['response'])
+            
+            return {
+                "type": "single_persona_response",
+                "session_id": session.session_id,
+                "persona": response,
+                "context_summary": self.context_manager.get_context_summary(session.messages)
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in chat_with_persona: {str(e)}")
+            return {
+                "type": "error",
+                "session_id": session_id,
+                "message": "I encountered an error generating a response. Please try again.",
+                "error": str(e)
+            }
+    
+    def _needs_clarification(self, session: ConversationContext, user_input: str) -> bool:
+        """
+        Determine if user input needs clarification
+        """
+        # Don't ask for clarification if this is a follow-up message
+        user_messages = session.get_messages_by_role("user")
+        if len(user_messages) > 1:
+            return False
+        
+        # Check if input is vague
+        vague_patterns = [
+            r"i'm (not sure|unsure|confused|lost)",
+            r"i (don't know|dunno) (what|how|where)",
+            r"help me with (my|the|a) (thesis|research|phd)",
+            r"(what should i|how do i|where do i start)",
+            r"i need (help|advice|guidance)$",
+            r"(stuck|struggling) with",
+            r"(any|some) (advice|suggestions|ideas)$",
+            r"^(help|advice|guidance)$",
+        ]
+        
+        user_lower = user_input.lower().strip()
+        
+        for pattern in vague_patterns:
+            if re.search(pattern, user_lower):
+                return True
+        
+        # Check if input is too short (likely vague)
+        if len(user_input.split()) < 8:
+            return True
+        
+        return False
+    
+    async def _generate_clarification_question(self, session: ConversationContext) -> str:
+        """
+        Generate a clarification question based on context
+        """
+        user_messages = session.get_messages_by_role("user")
+        if not user_messages:
+            return "What specific aspect of your PhD journey would you like guidance on?"
+        
+        latest_message = user_messages[-1]['content']
+        
+        # Extract what information we might be missing
+        missing_info = []
+        
+        # Check for research area
+        research_keywords = ["computer science", "biology", "psychology", "physics", "chemistry", 
+                           "engineering", "literature", "history", "mathematics", "sociology"]
+        if not any(keyword in latest_message.lower() for keyword in research_keywords):
+            missing_info.append("research area")
+        
+        # Check for specific question type
+        question_keywords = ["methodology", "theory", "writing", "analysis", "data", "literature review"]
+        if not any(keyword in latest_message.lower() for keyword in question_keywords):
+            missing_info.append("specific aspect")
+        
+        # Check for academic stage
+        stage_keywords = ["first year", "second year", "third year", "qualifying", "dissertation", 
+                         "defense", "proposal", "coursework"]
+        if not any(keyword in latest_message.lower() for keyword in stage_keywords):
+            missing_info.append("PhD stage")
+        
+        # Generate appropriate clarification question
+        if "research area" in missing_info:
+            return "What field or discipline are you studying in?"
+        elif "specific aspect" in missing_info:
+            return "What specific aspect of your research would you like guidance on?"
+        elif "PhD stage" in missing_info:
+            return "What stage of your PhD program are you currently in?"
+        else:
+            return "Could you provide more details about your specific situation or question?"
+    
+    async def _generate_persona_responses(self, 
+                                        session: ConversationContext, 
+                                        response_length: str) -> List[Dict[str, Any]]:
+        """
+        Generate responses from all personas
+        """
+        responses = []
+        
+        # Get the conversation context for personas
+        context_messages = session.get_recent_messages(limit=20)
+        
+        for persona_id, persona in self.personas.items():
+            try:
+                response_data = await self._generate_single_persona_response(
+                    session, persona, response_length
+                )
+                responses.append(response_data)
+                
+                # Add persona response to session
+                session.append_message(persona_id, response_data['response'])
+                
+            except Exception as e:
+                logger.error(f"Error generating response for persona {persona_id}: {str(e)}")
+                # Add fallback response
+                responses.append({
+                    "persona_id": persona_id,
+                    "persona_name": persona.name,
+                    "response": self._get_fallback_response(persona_id),
+                    "error": True
+                })
+        
+        return responses
+    
+    async def _generate_single_persona_response(self, 
+                                              session: ConversationContext,
+                                              persona: Persona, 
+                                              response_length: str) -> Dict[str, Any]:
+        """
+        Generate response from a single persona
+        """
+        try:
+            # Get conversation context
+            context_messages = session.get_recent_messages(limit=20)
+            
+            # Generate response using persona
+            response = await persona.respond(context_messages, response_length)
+            
+            # Validate response
+            if not self._is_valid_response(response, persona.id):
+                response = self._get_fallback_response(persona.id)
+            
+            return {
+                "persona_id": persona.id,
+                "persona_name": persona.name,
+                "response": response,
+                "error": False
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in _generate_single_persona_response for {persona.id}: {str(e)}")
+            return {
+                "persona_id": persona.id,
+                "persona_name": persona.name,
+                "response": self._get_fallback_response(persona.id),
+                "error": True
+            }
+    
+    def _is_valid_response(self, response: str, persona_id: str) -> bool:
+        """Validate response quality"""
+        if not response or len(response.strip()) < 10:
+            return False
+        
+        if len(response) > 2000:  # Too long
+            return False
+        
+        # Check for AI confusion indicators
+        confusion_indicators = [
+            f"Thank you, Dr. {persona_id.title()}",
+            "Assistant:",
+            f"Dr. {persona_id.title()}:",
+            "excellent discussion, Assistant"
+        ]
+        
+        return not any(indicator in response for indicator in confusion_indicators)
+    
+    def _get_fallback_response(self, persona_id: str) -> str:
+        """Get persona-specific fallback response"""
+        fallbacks = {
+            "methodist": "Let's focus on your research methodology. What specific methodological approach are you considering?",
+            "theorist": "I'd like to explore the theoretical foundation of your work. What conceptual framework guides your research?",
+            "pragmatist": "Let's take a practical approach. What's the most pressing decision you need to make about your research right now?"
+        }
+        return fallbacks.get(persona_id, "I'd be happy to help. Could you provide more specific details about your question?")
+    
+    def get_session_info(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get information about a session"""
+        session = self.session_manager.get_session(session_id)
+        if session:
+            return {
+                "session_id": session.session_id,
+                "message_count": len(session.messages),
+                "uploaded_files": session.uploaded_files,
+                "created_at": session.created_at.isoformat(),
+                "last_accessed": session.last_accessed.isoformat(),
+                "context_summary": self.context_manager.get_context_summary(session.messages)
+            }
+        return None
+    
+    def reset_session(self, session_id: str) -> bool:
+        """Reset a session (clear messages but keep metadata)"""
+        session = self.session_manager.get_session(session_id)
+        if session:
+            session.clear_messages()
+            return True
+        return False
+    
+    def delete_session(self, session_id: str) -> bool:
+        """Delete a session completely"""
+        return self.session_manager.delete_session(session_id)

multi_llm_chatbot_backend/app/llm/improved_gemini_client.py

@@ -0,0 +1,106 @@
+import httpx
+import os
+from typing import List
+from app.llm.llm_client import LLMClient
+from app.core.context_manager import get_context_manager
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ImprovedGeminiClient(LLMClient):
+    def __init__(self, model_name: str = None):
+        if model_name is None:
+            model_name = os.getenv("GEMINI_MODEL", "gemini-2.0-flash-exp")
+        
+        self.model_name = model_name
+        self.api_key = os.getenv("GEMINI_API_KEY")
+        if not self.api_key:
+            raise ValueError("GEMINI_API_KEY environment variable is required")
+        
+        self.base_url = "https://generativelanguage.googleapis.com/v1beta/models"
+        self.context_manager = get_context_manager()
+    
+    async def generate(self, system_prompt: str, context: List[dict], temperature: float, max_tokens: int) -> str:
+        """
+        Generate response using improved context management
+        """
+        try:
+            # Use context manager to prepare optimal context window
+            context_window = self.context_manager.prepare_context_for_llm(
+                messages=context,
+                system_prompt=system_prompt,
+                llm_provider="gemini"
+            )
+            
+            logger.debug(f"Context prepared: {len(context_window.messages)} messages, "
+                        f"~{context_window.total_tokens} tokens, truncated={context_window.truncated}")
+            
+            payload = {
+                "contents": context_window.messages,
+                "generationConfig": {
+                    "temperature": temperature,
+                    "topK": 40,
+                    "topP": 0.9,
+                    "maxOutputTokens": max_tokens,
+                    "stopSequences": ["Student:", "Question:", "\n\nStudent:", "\n\nQuestion:"]
+                },
+                "safetySettings": [
+                    {
+                        "category": "HARM_CATEGORY_HARASSMENT",
+                        "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                    },
+                    {
+                        "category": "HARM_CATEGORY_HATE_SPEECH",
+                        "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                    },
+                    {
+                        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                        "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                    },
+                    {
+                        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+                        "threshold": "BLOCK_MEDIUM_AND_ABOVE"
+                    }
+                ]
+            }
+            
+            url = f"{self.base_url}/{self.model_name}:generateContent?key={self.api_key}"
+            
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(url, json=payload)
+                response.raise_for_status()
+                
+                result = response.json()
+                
+                if "candidates" in result and result["candidates"]:
+                    candidate = result["candidates"][0]
+                    if "content" in candidate and "parts" in candidate["content"]:
+                        text = candidate["content"]["parts"][0].get("text", "")
+                        return self._clean_response(text)
+                
+                # Handle safety filter or other issues
+                if "promptFeedback" in result:
+                    feedback = result["promptFeedback"]
+                    logger.warning(f"Gemini prompt feedback: {feedback}")
+                
+                return "I apologize, but I'm unable to provide a response to that query."
+                
+        except httpx.TimeoutException:
+            logger.error("Gemini API timeout")
+            return "I'm experiencing a delay in processing. Please try again."
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Gemini API HTTP error: {e.response.status_code} - {e.response.text}")
+            return "I'm having trouble accessing the AI service. Please try again."
+        except Exception as e:
+            logger.error(f"Unexpected error in Gemini client: {str(e)}")
+            return "I encountered an unexpected error. Please try again."
+    
+    def _clean_response(self, response: str) -> str:
+        """Clean up response text"""
+        # Remove common issues
+        response = response.strip()
+        
+        # Remove duplicate spaces and normalize
+        response = ' '.join(response.split())
+        
+        return response

multi_llm_chatbot_backend/app/llm/improved_ollama_client.py

@@ -0,0 +1,109 @@
+import httpx
+from typing import List
+from app.llm.llm_client import LLMClient
+from app.core.context_manager import get_context_manager
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ImprovedOllamaClient(LLMClient):
+    def __init__(self, model_name: str = "llama3.2:1b", base_url: str = "http://localhost:11434"):
+        self.model_name = model_name
+        self.base_url = base_url
+        self.context_manager = get_context_manager()
+    
+    async def generate(self, system_prompt: str, context: List[dict], temperature: float, max_tokens: int) -> str:
+        """
+        Generate response using improved context management
+        """
+        try:
+            # Use context manager to prepare optimal context
+            context_window = self.context_manager.prepare_context_for_llm(
+                messages=context,
+                system_prompt=system_prompt,
+                llm_provider="ollama"
+            )
+            
+            logger.debug(f"Context prepared: ~{context_window.total_tokens} tokens, "
+                        f"truncated={context_window.truncated}")
+            
+            # For Ollama, context_window.messages is a formatted prompt string
+            formatted_prompt = context_window.messages
+            
+            payload = {
+                "model": self.model_name,
+                "prompt": formatted_prompt,
+                "stream": False,
+                "options": {
+                    "temperature": temperature,
+                    "top_p": 0.9,
+                    "top_k": 40,
+                    "num_predict": max_tokens,
+                    "repeat_penalty": 1.1,
+                    "stop": ["\n\nStudent:", "\n\nUser:", "Question:", "Student:"]
+                }
+            }
+            
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.post(f"{self.base_url}/api/generate", json=payload)
+                response.raise_for_status()
+                
+                result = response.json()
+                text = result.get("response", "").strip()
+                
+                return self._clean_response(text)
+                
+        except httpx.ConnectError:
+            logger.error(f"Cannot connect to Ollama at {self.base_url}")
+            return "I'm unable to connect to the local AI service. Please ensure Ollama is running."
+        except httpx.TimeoutException:
+            logger.error("Ollama request timeout")
+            return "The AI service is taking too long to respond. Please try again."
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Ollama HTTP error: {e.response.status_code}")
+            return "The AI service encountered an error. Please try again."
+        except Exception as e:
+            logger.error(f"Unexpected error in Ollama client: {str(e)}")
+            return "I encountered an unexpected error. Please try again."
+    
+    def _clean_response(self, response: str) -> str:
+        """Clean up common response issues"""
+        # Remove common prefixes that indicate AI confusion
+        prefixes_to_remove = [
+            "Here are 2-3 sentence", "Here's an expansion", "Assistant:",
+            "Dr. Methodist:", "Dr. Theorist:", "Dr. Pragmatist:",
+            "Methodist Advisor:", "Theorist Advisor:", "Pragmatist Advisor:",
+        ]
+        
+        for prefix in prefixes_to_remove:
+            if response.startswith(prefix):
+                response = response[len(prefix):].strip()
+        
+        # Remove trailing incomplete sentences
+        sentences = response.split('.')
+        if len(sentences) > 1 and len(sentences[-1].strip()) < 10:
+            response = '.'.join(sentences[:-1]) + '.'
+        
+        # Remove excessive academic fluff
+        fluff_patterns = [
+            "conceptual insights:", "actionable advice:", "my inquisitive student",
+            "excellent question", "thank you for", "assistant!"
+        ]
+        
+        for pattern in fluff_patterns:
+            response = response.replace(pattern, "").strip()
+        
+        # Normalize whitespace
+        response = ' '.join(response.split())
+        
+        return response
+
+    def _is_poor_quality(self, response: str) -> bool:
+        """Check if response quality is poor"""
+        poor_indicators = [
+            "Thank you, Dr." in response,
+            "Assistant:" in response,
+            len(response.split()) > 150,  # Too verbose
+            response.count("?") > 3,  # Too many questions
+        ]
+        return any(poor_indicators)