add chat specific context

multi_llm_chatbot_backend/app/api/routes/chat.py

@@ -1,46 +1,165 @@
-from fastapi import APIRouter, Request, HTTPException, Body
+from fastapi import APIRouter, Request, HTTPException, Body, Depends
 from app.models.persona import Persona
 from app.core.session_manager import get_session_manager
-from app.api.utils import get_or_create_session_for_request
+from app.api.utils import get_or_create_session_for_request_async
 from app.core.bootstrap import chat_orchestrator
+from app.core.auth import get_current_active_user
+from app.models.user import User
 from pydantic import BaseModel
+from typing import Optional
 import logging
+from app.core.database import get_database
+from bson import ObjectId
 
 logger = logging.getLogger(__name__)
 
 router = APIRouter()
-
 session_manager = get_session_manager()
 
-# Keep all the same data models as before
+# Enhanced data models
 class UserInput(BaseModel):
     user_input: str
 
 class ChatMessage(BaseModel):
     user_input: str
-    session_id: str = None
+    session_id: Optional[str] = None
+    chat_session_id: Optional[str] = None  # MongoDB chat session ID
     response_length: str = "medium"
 
 class ReplyToAdvisor(BaseModel):
     user_input: str
     advisor_id: str
     original_message_id: str = None
+    chat_session_id: Optional[str] = None
 
 class PersonaQuery(BaseModel):
     question: str
     persona: str
 
+class SwitchChatRequest(BaseModel):
+    chat_session_id: str
+
+class NewChatRequest(BaseModel):
+    title: Optional[str] = "New Chat"
+
+@router.post("/switch-chat")
+async def switch_to_chat(
+    request: SwitchChatRequest, 
+    req: Request,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Switch to an existing chat session and load its context
+    FIXED VERSION - Returns messages in correct frontend format
+    """
+    try:
+        # Load the chat session into memory context
+        memory_session_id = await get_or_create_session_for_request_async(
+            req, 
+            chat_session_id=request.chat_session_id,
+            user_id=str(current_user.id)
+        )
+        
+        if not memory_session_id:
+            raise HTTPException(status_code=404, detail="Chat session not found")
+        
+        # Get the loaded session
+        session = session_manager.get_session(memory_session_id)
+        
+        # Get the original MongoDB chat session to retrieve messages in proper format
+        db = get_database()
+        chat_session = await db.chat_sessions.find_one({
+            "_id": ObjectId(request.chat_session_id),
+            "user_id": current_user.id,
+            "is_active": True
+        })
+        
+        if not chat_session:
+            raise HTTPException(status_code=404, detail="Chat session not found in database")
+        
+        # Return the messages in the original frontend format from MongoDB
+        original_messages = chat_session.get("messages", [])
+        
+        logger.info(f"Switching to chat {request.chat_session_id} with {len(original_messages)} messages")
+        
+        return {
+            "status": "success",
+            "memory_session_id": memory_session_id,
+            "chat_session_id": request.chat_session_id,
+            "message_count": len(original_messages),
+            "context": {
+                "messages": original_messages,  # Return original format messages
+                "rag_info": session.get_rag_stats()
+            }
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error switching to chat: {e}")
+        raise HTTPException(status_code=500, detail="Failed to switch to chat")
+
+@router.post("/new-chat")
+async def create_new_chat(
+    request: NewChatRequest,
+    req: Request,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Create a new chat with fresh context
+    """
+    try:
+        # Create a completely new session (no chat_session_id means fresh context)
+        memory_session_id = await get_or_create_session_for_request_async(req)
+        
+        # Ensure the session is completely clean
+        session = session_manager.get_session(memory_session_id)
+        session.clear_all_data()  # This clears both messages and documents
+        
+        return {
+            "status": "success",
+            "memory_session_id": memory_session_id,
+            "message": "New chat created with fresh context",
+            "context": {
+                "messages": [],
+                "rag_info": {"total_documents": 0, "total_chunks": 0}
+            }
+        }
+        
+    except Exception as e:
+        logger.error(f"Error creating new chat: {e}")
+        raise HTTPException(status_code=500, detail="Failed to create new chat")
 
 @router.post("/chat-sequential")
 async def chat_sequential_enhanced(message: ChatMessage, request: Request):
     """
-    Enhanced sequential chat with orchestrator clarification for vague queries.
+    Enhanced sequential chat with proper session management
     """
     try:
-        # Get or create session
-        session_id = get_or_create_session_for_request(request, message.session_id)
+        # Determine session ID based on whether this is an existing chat or new
+        if message.chat_session_id:
+            # This is an existing chat - we should have already loaded it via switch-chat
+            # Use the memory session ID format
+            session_id = f"chat_{message.chat_session_id}"
+            
+            # Verify the session exists in memory
+            if session_id not in session_manager.sessions:
+                # If not in memory, this means switch-chat wasn't called
+                # We should load it now (but log a warning)
+                logger.warning(f"Chat session {message.chat_session_id} not in memory, loading now")
+                session_id = await get_or_create_session_for_request_async(
+                    request,
+                    chat_session_id=message.chat_session_id,
+                    user_id="anonymous"  # We don't have user context here
+                )
+        else:
+            # This is a new chat or no specific chat session
+            session_id = await get_or_create_session_for_request_async(
+                request, 
+                session_id_override=message.session_id
+            )
         
-        # STEP 1: Check if clarification is needed using orchestrator's logic
+        # Get the session
         session = session_manager.get_session(session_id)
         
         # Debug logging
@@ -69,10 +188,7 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
                 "session_id": session_id
             }
         
-        # STEP 2: No clarification needed - proceed with intelligent persona ordering
-        # (user message already added to session above)
-        
-        # Get intelligently ordered personas based on context (TOP 3 ONLY)
+        # No clarification needed - proceed with intelligent persona ordering
         top_personas = await chat_orchestrator.get_top_personas(
             session_id=session_id, 
             k=3  # Limit to top 3 most relevant personas
@@ -100,7 +216,6 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
                         "response": persona_result["response"]
                     })
                 else:
-                    # Fallback response
                     responses.append({
                         "persona": chat_orchestrator.personas[persona_id].name,
                         "persona_id": persona_id,
@@ -109,7 +224,6 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
                     
             except Exception as e:
                 logger.error(f"Error generating response for persona {persona_id}: {str(e)}")
-                # Error fallback
                 responses.append({
                     "persona": chat_orchestrator.personas[persona_id].name,
                     "persona_id": persona_id,
@@ -118,7 +232,8 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
         
         return {
             "type": "sequential_responses",
-            "responses": responses
+            "responses": responses,
+            "session_id": session_id  # Include session ID in response
         }
 
     except Exception as e:
@@ -128,29 +243,30 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
             "responses": [{
                 "persona": "System",
                 "response": "I'm having trouble processing your request. Could you please try again?"
-            }]
+            }],
+            "session_id": session_id if 'session_id' in locals() else None
         }
-    
+
+# Keep existing endpoints but update them to use async session management
+
 @router.post("/chat/{persona_id}")
 async def chat_with_specific_advisor(persona_id: str, input: UserInput, request: Request):
-    """Chat with a specific advisor - SAME INTERFACE"""
+    """Chat with a specific advisor - UPDATED"""
     try:
         if persona_id not in chat_orchestrator.personas:
             raise HTTPException(status_code=404, detail=f"Persona '{persona_id}' not found")
 
-        # Get session using compatibility layer
-        session_id = get_or_create_session_for_request(request)
+        # Use async session management
+        session_id = await get_or_create_session_for_request_async(request)
         
-        # Use new orchestrator
         result = await chat_orchestrator.chat_with_persona(
             user_input=input.user_input,
             persona_id=persona_id,
             session_id=session_id
         )
         
-        # FIX: Handle the actual response structure from orchestrator
+        # Handle response structure
         if result.get("type") == "single_persona_response" and "persona" in result:
-            # New expected structure
             persona_data = result["persona"]
             return {
                 "persona": persona_data["persona_name"],
@@ -158,20 +274,12 @@ async def chat_with_specific_advisor(persona_id: str, input: UserInput, request:
                 "response": persona_data["response"]
             }
         elif "persona_id" in result and "response" in result:
-            # Current actual structure from orchestrator
             return {
                 "persona": result["persona_name"],
                 "persona_id": result["persona_id"],
                 "response": result["response"]
             }
-        elif result.get("type") == "error" or "error" in result:
-            # Error handling
-            return {
-                "persona": "System",
-                "response": result.get("error", "I'm having trouble generating a response right now. Please try again.")
-            }
         else:
-            # Fallback
             return {
                 "persona": "System",
                 "response": "I'm having trouble generating a response right now. Please try again."
@@ -188,32 +296,32 @@ async def chat_with_specific_advisor(persona_id: str, input: UserInput, request:
 
 @router.post("/reply-to-advisor")
 async def reply_to_advisor(reply: ReplyToAdvisor, request: Request):
-    """Reply to a specific advisor with proper context"""
+    """Reply to a specific advisor with proper context - UPDATED"""
     try:
         if reply.advisor_id not in chat_orchestrator.personas:
             raise HTTPException(status_code=404, detail=f"Advisor '{reply.advisor_id}' not found")
 
-        # Get session using compatibility layer
-        session_id = get_or_create_session_for_request(request)
+        # Handle session management for existing chats
+        if reply.chat_session_id:
+            session_id = f"chat_{reply.chat_session_id}"
+        else:
+            session_id = await get_or_create_session_for_request_async(request)
         
-        # Get the session to access conversation history
         session = session_manager.get_session(session_id)
         
         # Find the original message being replied to for context
         original_message = None
         if reply.original_message_id:
-            # Look through session history to find the original message
             for msg in session.messages:
                 if getattr(msg, 'id', None) == reply.original_message_id:
                     original_message = msg.content
                     break
         
-        # Create context-aware input that includes the reply context
+        # Create context-aware input
         contextual_input = reply.user_input
         if original_message:
             contextual_input = f"[Replying to your previous message: '{original_message[:100]}...'] {reply.user_input}"
         
-        # Use orchestrator with context
         result = await chat_orchestrator.chat_with_persona(
             user_input=contextual_input,
             persona_id=reply.advisor_id,
@@ -254,66 +362,13 @@ async def reply_to_advisor(reply: ReplyToAdvisor, request: Request):
             "persona": "System",
             "response": "I'm having trouble generating a reply right now. Please try again."
         }
-    
-@router.post("/chat/{persona_id}")
-async def chat_with_specific_persona(persona_id: str, message: ChatMessage, request: Request):
-    """
-    Chat with a specific persona - Enhanced with RAG debugging
-    
-    This endpoint helps debug RAG integration by testing individual personas
-    """
-    try:
-        session_id = get_or_create_session_for_request(request, message.session_id)
-        
-        # Validate persona exists
-        if persona_id not in chat_orchestrator.personas:
-            available_personas = list(chat_orchestrator.personas.keys())
-            raise HTTPException(
-                status_code=400, 
-                detail=f"Persona '{persona_id}' not found. Available: {available_personas}"
-            )
-        
-        # Use the enhanced orchestrator method
-        result = await chat_orchestrator.chat_with_persona(
-            user_input=message.user_input,
-            persona_id=persona_id,
-            session_id=session_id,
-            response_length=message.response_length or "medium"
-        )
-        
-        # Fix: Handle the response structure properly
-        if result.get("type") == "single_persona_response" and "persona" in result:
-            persona_data = result["persona"]
-            
-            # Add debugging information
-            result["debug_info"] = {
-                "persona_id": persona_id,
-                "session_id": session_id,
-                "query_length": len(message.user_input),
-                "rag_manager_available": True,
-                "used_documents": persona_data.get("used_documents", False),
-                "chunks_used": persona_data.get("document_chunks_used", 0)
-            }
-        
-        return result
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error in individual persona chat: {str(e)}")
-        return {
-            "type": "error",
-            "message": f"Error chatting with {persona_id}: {str(e)}",
-            "persona_id": persona_id
-        }
-    
+
 @router.post("/ask/")
 async def ask_question(query: PersonaQuery, request: Request):
-    """Ask question - SAME INTERFACE"""
+    """Ask question - UPDATED"""
     try:
-        session_id = get_or_create_session_for_request(request)
+        session_id = await get_or_create_session_for_request_async(request)
         
-        # Use the new orchestrator
         result = await chat_orchestrator.chat_with_persona(
             user_input=query.question,
             persona_id=query.persona,

multi_llm_chatbot_backend/app/api/routes/sessions.py

@@ -1,54 +1,222 @@
-from fastapi import APIRouter, Request, HTTPException
+from fastapi import APIRouter, Request, HTTPException, Depends
 from app.core.session_manager import get_session_manager
-from app.api.utils import get_or_create_session_for_request
+from app.api.utils import get_or_create_session_for_request_async
+from app.core.auth import get_current_active_user
+from app.models.user import User
+from pydantic import BaseModel
+from typing import Optional
 import logging
 
 logger = logging.getLogger(__name__)
 
 router = APIRouter()
-
 session_manager = get_session_manager()
 
+class ResetSessionRequest(BaseModel):
+    chat_session_id: Optional[str] = None
+    force_new: bool = False
+
 @router.get("/context")
-async def get_context(request: Request):
+async def get_context(
+    request: Request,
+    chat_session_id: Optional[str] = None,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Get context for current session - ENHANCED
+    Now properly handles different chat sessions
+    """
     try:
-        session_id = get_or_create_session_for_request(request)
+        # Determine which session to get context for
+        if chat_session_id:
+            # Getting context for a specific chat session
+            session_id = await get_or_create_session_for_request_async(
+                request,
+                chat_session_id=chat_session_id,
+                user_id=str(current_user.id)
+            )
+        else:
+            # Getting context for current session
+            session_id = await get_or_create_session_for_request_async(request)
+        
         session = session_manager.get_session(session_id)
         rag_stats = session.get_rag_stats()
+        
+        logger.info(f"Retrieved context for session {session_id}: {len(session.messages)} messages")
+        
         return {
+            "session_id": session_id,
+            "chat_session_id": chat_session_id,
             "messages": session.messages,
             "rag_info": {
                 "total_documents": rag_stats.get("total_documents", 0),
                 "total_chunks": rag_stats.get("total_chunks", 0),
                 "documents": rag_stats.get("documents", [])
+            },
+            "context_stats": {
+                "message_count": len(session.messages),
+                "user_messages": len([m for m in session.messages if m.get('role') == 'user']),
+                "uploaded_files": session.uploaded_files,
+                "total_upload_size": session.total_upload_size,
+                "created_at": session.created_at.isoformat(),
+                "last_accessed": session.last_accessed.isoformat()
             }
         }
+        
     except Exception as e:
         logger.error(f"Error getting context: {str(e)}")
-        return {"messages": [], "rag_info": {"total_documents": 0, "total_chunks": 0}}
-
+        return {
+            "session_id": None,
+            "messages": [], 
+            "rag_info": {"total_documents": 0, "total_chunks": 0},
+            "error": str(e)
+        }
 
 @router.post("/reset-session")
-async def reset_session(request: Request):
+async def reset_session(
+    reset_request: ResetSessionRequest,
+    request: Request,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Reset session - ENHANCED
+    Now properly handles different reset scenarios
+    """
     try:
-        session_id = get_or_create_session_for_request(request)
-        success = session_manager.reset_session_completely(session_id)
-
-        if success:
-            return {"status": "reset", "message": "Session and all documents reset successfully"}
+        if reset_request.force_new:
+            # Force create a completely new session
+            session_id = session_manager.create_session()
+            session = session_manager.get_session(session_id)
+            session.clear_all_data()
+            
+            logger.info(f"Force created new session: {session_id}")
+            
+            return {
+                "status": "reset", 
+                "message": "New session created with fresh context",
+                "session_id": session_id,
+                "chat_session_id": None
+            }
+        
+        elif reset_request.chat_session_id:
+            # Reset a specific chat session context
+            session_id = f"chat_{reset_request.chat_session_id}"
+            
+            if session_id in session_manager.sessions:
+                success = session_manager.reset_session_completely(session_id)
+                message = "Chat session context reset successfully" if success else "Failed to reset chat session context"
+            else:
+                # Create fresh context for this chat
+                session = session_manager.get_session(session_id)
+                session.clear_all_data()
+                success = True
+                message = "Fresh context created for chat session"
+            
+            logger.info(f"Reset chat session {reset_request.chat_session_id}, memory session: {session_id}")
+            
+            return {
+                "status": "reset" if success else "error",
+                "message": message,
+                "session_id": session_id,
+                "chat_session_id": reset_request.chat_session_id
+            }
+        
         else:
-            return {"status": "error", "message": "Failed to reset session"}
+            # Reset current session
+            session_id = await get_or_create_session_for_request_async(request)
+            success = session_manager.reset_session_completely(session_id)
+            
+            logger.info(f"Reset current session: {session_id}")
+            
+            return {
+                "status": "reset" if success else "error",
+                "message": "Current session reset successfully" if success else "Failed to reset current session",
+                "session_id": session_id
+            }
+            
     except Exception as e:
         logger.error(f"Error resetting session: {e}")
-        return {"status": "error", "message": "Failed to reset session"}
-
+        return {"status": "error", "message": f"Failed to reset session: {str(e)}"}
 
 @router.get("/session-stats")
-async def get_session_stats(request: Request):
+async def get_session_stats(
+    request: Request,
+    chat_session_id: Optional[str] = None,
+    current_user: User = Depends(get_current_active_user)
+):
+    """
+    Get session statistics - ENHANCED
+    Now provides detailed stats for different session types
+    """
     try:
-        session_id = get_or_create_session_for_request(request)
+        if chat_session_id:
+            # Stats for specific chat session
+            session_id = f"chat_{chat_session_id}"
+        else:
+            # Stats for current session
+            session_id = await get_or_create_session_for_request_async(request)
+        
         stats = session_manager.get_session_stats(session_id)
+        
+        # Add additional context
+        stats["session_type"] = "chat_session" if chat_session_id else "current_session"
+        stats["chat_session_id"] = chat_session_id
+        
         return stats
+        
     except Exception as e:
         logger.error(f"Error getting session stats: {str(e)}")
         return {"error": str(e)}
+
+@router.get("/active-sessions")
+async def get_active_sessions(current_user: User = Depends(get_current_active_user)):
+    """
+    Get all active sessions for debugging
+    """
+    try:
+        active_count = session_manager.get_active_session_count()
+        
+        # Get overview of sessions (don't return full content for privacy)
+        session_overview = {}
+        for session_id, session in session_manager.sessions.items():
+            session_overview[session_id] = {
+                "message_count": len(session.messages),
+                "uploaded_files": len(session.uploaded_files),
+                "created_at": session.created_at.isoformat(),
+                "last_accessed": session.last_accessed.isoformat(),
+                "is_chat_session": session_id.startswith("chat_")
+            }
+        
+        return {
+            "active_session_count": active_count,
+            "sessions": session_overview
+        }
+        
+    except Exception as e:
+        logger.error(f"Error getting active sessions: {str(e)}")
+        return {"error": str(e)}
+
+@router.post("/cleanup-sessions")
+async def cleanup_expired_sessions(current_user: User = Depends(get_current_active_user)):
+    """
+    Manually trigger session cleanup
+    """
+    try:
+        initial_count = session_manager.get_active_session_count()
+        
+        # Force cleanup
+        session_manager._cleanup_expired_sessions()
+        
+        final_count = session_manager.get_active_session_count()
+        cleaned_count = initial_count - final_count
+        
+        return {
+            "status": "success",
+            "message": f"Cleaned up {cleaned_count} expired sessions",
+            "sessions_before": initial_count,
+            "sessions_after": final_count
+        }
+        
+    except Exception as e:
+        logger.error(f"Error during session cleanup: {str(e)}")
+        return {"status": "error", "message": str(e)}

multi_llm_chatbot_backend/app/api/utils.py

@@ -1,24 +1,156 @@
 from typing import Optional
 from fastapi import Request
 from app.core.session_manager import get_session_manager
+from app.core.database import get_database
+from bson import ObjectId
+import logging
 
+logger = logging.getLogger(__name__)
 session_manager = get_session_manager()
 
-def get_or_create_session_for_request(request: Request, session_id_override: Optional[str] = None) -> str:
+async def load_chat_session_into_context(chat_session_id: str, user_id: str) -> Optional[str]:
     """
-    Get or create session for request using multiple strategies:
-    1. Explicit session ID
-    2. X-Session-ID header
-    3. Client IP fallback
+    Load a MongoDB chat session into in-memory context
+    Returns the in-memory session_id to use
     """
+    try:
+        db = get_database()
+        
+        # Get the chat session from MongoDB
+        chat_session = await db.chat_sessions.find_one({
+            "_id": ObjectId(chat_session_id),
+            "user_id": user_id,
+            "is_active": True
+        })
+        
+        if not chat_session:
+            logger.warning(f"Chat session {chat_session_id} not found for user {user_id}")
+            return None
+        
+        # Create or get in-memory session with a unique ID based on chat session
+        memory_session_id = f"chat_{chat_session_id}"
+        memory_session = session_manager.get_session(memory_session_id)
+        
+        # Clear existing messages and load from MongoDB
+        memory_session.clear_messages()
+        
+        # Load all messages from the chat session with proper format conversion
+        messages = chat_session.get("messages", [])
+        for message in messages:
+            # Convert MongoDB message format to session manager format
+            # MongoDB format: {type: 'user'/'advisor', content: '', advisorId: '', ...}
+            # Session format: {role: '', content: '', timestamp: ''}
+            
+            msg_type = message.get("type", "user")
+            content = message.get("content", "")
+            timestamp = message.get("timestamp", "")
+            
+            # Map message types to roles for session manager
+            if msg_type == "user":
+                role = "user"
+            elif msg_type == "advisor":
+                role = "assistant"
+                # For advisor messages, include advisor info in content if needed
+                advisor_name = message.get("advisorName", "")
+                if advisor_name:
+                    # Store advisor info as metadata that can be retrieved
+                    role = f"advisor_{message.get('advisorId', 'unknown')}"
+            elif msg_type == "system":
+                role = "system"
+            elif msg_type == "error":
+                role = "system"
+            elif msg_type == "document_upload":
+                role = "system"
+            elif msg_type == "clarification":
+                role = "system"
+            else:
+                role = "user"  # Default fallback
+            
+            # Add the message to session with original structure preserved
+            memory_session.append_message(role, content)
+            
+            # Store original message metadata for frontend reconstruction
+            if not hasattr(memory_session, 'original_messages'):
+                memory_session.original_messages = []
+            
+            memory_session.original_messages.append(message)
+        
+        logger.info(f"Loaded {len(messages)} messages into session {memory_session_id}")
+        return memory_session_id
+        
+    except Exception as e:
+        logger.error(f"Error loading chat session into context: {e}")
+        return None
+
+def get_or_create_session_for_request(
+    request: Request, 
+    session_id_override: Optional[str] = None,
+    chat_session_id: Optional[str] = None,
+    user_id: Optional[str] = None
+) -> str:
+    """
+    Enhanced session management that properly handles chat switching
+    
+    Args:
+        request: FastAPI request object
+        session_id_override: Explicit session ID to use
+        chat_session_id: MongoDB chat session ID (for existing chats)
+        user_id: User ID (for loading existing chats)
+    """
+    
+    # Case 1: Loading an existing chat session
+    if chat_session_id and user_id:
+        try:
+            # We need to handle this in the calling function since this isn't async
+            # Return a special identifier that the calling function can handle
+            return f"load_chat_{chat_session_id}"
+            
+        except Exception as e:
+            logger.error(f"Error handling chat session load: {e}")
+            # Fall through to create new session
+    
+    # Case 2: Explicit session ID provided
+    if session_id_override:
+        return session_id_override
+
+    # Case 3: Check for session header
+    session_header = request.headers.get("X-Session-ID")
+    if session_header:
+        return session_header
+
+    # Case 4: Create a truly new session (don't fall back to IP)
+    # This ensures each new chat gets its own context
+    new_session_id = session_manager.create_session()
+    logger.info(f"Created new session: {new_session_id}")
+    return new_session_id
+
+async def get_or_create_session_for_request_async(
+    request: Request, 
+    session_id_override: Optional[str] = None,
+    chat_session_id: Optional[str] = None,
+    user_id: Optional[str] = None
+) -> str:
+    """
+    Async version that properly handles chat session loading
+    """
+    
+    # Case 1: Loading an existing chat session
+    if chat_session_id and user_id:
+        memory_session_id = await load_chat_session_into_context(chat_session_id, user_id)
+        if memory_session_id:
+            return memory_session_id
+        # If loading failed, create new session
+    
+    # Case 2: Explicit session ID provided
     if session_id_override:
         return session_id_override
 
+    # Case 3: Check for session header
     session_header = request.headers.get("X-Session-ID")
     if session_header:
         return session_header
 
-    client_ip = request.client.host if request.client else "unknown"
-    ip_session_id = f"ip_{client_ip}"
-    session = session_manager.get_session(ip_session_id)
-    return session.session_id
+    # Case 4: Create a truly new session
+    new_session_id = session_manager.create_session()
+    logger.info(f"Created new session: {new_session_id}")
+    return new_session_id

phd-advisor-frontend/src/components/Sidebar.js

@@ -28,6 +28,7 @@ const Sidebar = ({
   const [isLoading, setIsLoading] = useState(true);
   const [showUserMenu, setShowUserMenu] = useState(false);
   const [isCollapsed, setIsCollapsed] = useState(false);
+  const [isCreatingNewChat, setIsCreatingNewChat] = useState(false); // Add loading state for new chat creation
 
   useEffect(() => {
     if (authToken) {
@@ -42,6 +43,17 @@ const Sidebar = ({
     }
   }, [isCollapsed, onSidebarToggle]);
 
+  // Add effect to refresh when currentSessionId changes (new session created)
+  useEffect(() => {
+    if (currentSessionId && authToken) {
+      // Small delay to ensure the session is saved to database
+      const timer = setTimeout(() => {
+        fetchChatSessions();
+      }, 200);
+      return () => clearTimeout(timer);
+    }
+  }, [currentSessionId, authToken]);
+
   const fetchChatSessions = async () => {
     try {
       const response = await fetch('http://localhost:8000/api/chat-sessions', {
@@ -65,25 +77,21 @@ const Sidebar = ({
   };
 
   const handleNewChat = async () => {
+    setIsCreatingNewChat(true);
+    
     try {
-      const response = await fetch('http://localhost:8000/api/chat-sessions', {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${authToken}`,
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify({
-          title: `Chat ${new Date().toLocaleDateString()}`
-        })
-      });
-
-      if (response.ok) {
-        const newSession = await response.json();
-        setChatSessions(prev => [newSession, ...prev]);
-        onNewChat(newSession.id);
-      }
+      // Call the parent's new chat handler and wait for it to complete
+      await onNewChat();
+      
+      // Refresh the sessions list immediately after new chat is created
+      // The parent should have updated currentSessionId by now
+      await fetchChatSessions();
+      
     } catch (error) {
       console.error('Error creating new chat:', error);
+      // Optionally show an error message to the user
+    } finally {
+      setIsCreatingNewChat(false);
     }
   };
 
@@ -187,9 +195,13 @@ const Sidebar = ({
               </div>
             </div>
 
-            <button className="new-chat-button" onClick={handleNewChat}>
+            <button 
+              className="new-chat-button" 
+              onClick={handleNewChat}
+              disabled={isCreatingNewChat}
+            >
               <Plus size={16} />
-              <span>New Chat</span>
+              <span>{isCreatingNewChat ? 'Creating...' : 'New Chat'}</span>
             </button>
           </>
         )}
@@ -204,7 +216,12 @@ const Sidebar = ({
             >
               <ChevronRight size={20} />
             </button>
-            <button className="collapsed-new-chat" onClick={handleNewChat} title="New Chat">
+            <button 
+              className="collapsed-new-chat" 
+              onClick={handleNewChat} 
+              title="New Chat"
+              disabled={isCreatingNewChat}
+            >
               <Plus size={20} />
             </button>
           </div>
@@ -234,6 +251,11 @@ const Sidebar = ({
             <div className="loading-spinner"></div>
             {!isCollapsed && <span>Loading chats...</span>}
           </div>
+        ) : isCreatingNewChat ? (
+          <div className="loading-sessions">
+            <div className="loading-spinner"></div>
+            {!isCollapsed && <span>Creating new chat...</span>}
+          </div>
         ) : filteredSessions.length === 0 ? (
           <div className="no-sessions">
             {!isCollapsed && (searchTerm ? 'No chats found' : 'No chats yet')}

phd-advisor-frontend/src/pages/ChatPage.js

@@ -116,64 +116,85 @@ const ChatPage = ({ user, authToken, onNavigateToHome, onSignOut }) => {
   };
 
   const createNewSession = async (firstMessage = null) => {
-  try {
-    const title = firstMessage 
-      ? `${firstMessage.substring(0, 30)}...` 
-      : `Chat ${new Date().toLocaleDateString()}`;
+    try {
+      const title = firstMessage 
+        ? `${firstMessage.substring(0, 30)}...` 
+        : `Chat ${new Date().toLocaleDateString()}`;
 
-    const response = await fetch('http://localhost:8000/api/chat-sessions', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${authToken}`,
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({ title })
-    });
+      const response = await fetch('http://localhost:8000/api/chat-sessions', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${authToken}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ title })
+      });
 
-    if (response.ok) {
-      const newSession = await response.json();
-      setCurrentSessionId(newSession.id);
-      setCurrentSessionTitle(newSession.title);
-      return newSession.id;
-    } else {
-      console.error('Failed to create new session');
+      if (response.ok) {
+        const newSession = await response.json();
+        
+        // Update state immediately
+        setCurrentSessionId(newSession.id);
+        setCurrentSessionTitle(newSession.title);
+        
+        console.log('MongoDB session created:', newSession.id);
+        return newSession.id;
+      } else {
+        console.error('Failed to create new session');
+        return null;
+      }
+    } catch (error) {
+      console.error('Error creating new session:', error);
       return null;
     }
-  } catch (error) {
-    console.error('Error creating new session:', error);
-    return null;
-  }
-};
+  };
+
 
 // Load an existing chat session
 const loadChatSession = async (sessionId) => {
   if (!sessionId || isLoadingSession) return;
-
   setIsLoadingSession(true);
   try {
-    const response = await fetch(`http://localhost:8000/api/chat-sessions/${sessionId}`, {
+    // Use the new switch-chat endpoint that syncs context
+    const response = await fetch('http://localhost:8000/switch-chat', {
+      method: 'POST',
       headers: {
         'Authorization': `Bearer ${authToken}`,
         'Content-Type': 'application/json'
-      }
+      },
+      body: JSON.stringify({
+        chat_session_id: sessionId
+      })
     });
 
     if (response.ok) {
-      const session = await response.json();
-      setCurrentSessionId(session.id);
-      setCurrentSessionTitle(session.title);
-      
-      // Convert stored messages back to proper format
-      const formattedMessages = session.messages.map(msg => ({
-        ...msg,
-        timestamp: new Date(msg.timestamp)
-      }));
-      
-      setMessages(formattedMessages);
-      setReplyingTo(null);
-      setThinkingAdvisors([]);
-    } else {
-      console.error('Failed to load session');
+      const result = await response.json();
+      if (result.status === 'success') {
+        setCurrentSessionId(sessionId);
+        setCurrentSessionTitle(''); // Will be set from MongoDB data
+        
+        // Load the messages from the synced context
+        const formattedMessages = result.context.messages.map(msg => ({
+          ...msg,
+          timestamp: new Date(msg.timestamp)
+        }));
+        
+        setMessages(formattedMessages);
+        setReplyingTo(null);
+        setThinkingAdvisors([]);
+        
+        // Also get the session title from MongoDB
+        const sessionResponse = await fetch(`http://localhost:8000/api/chat-sessions/${sessionId}`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json'
+          }
+        });
+        if (sessionResponse.ok) {
+          const sessionData = await sessionResponse.json();
+          setCurrentSessionTitle(sessionData.title);
+        }
+      }
     }
   } catch (error) {
     console.error('Error loading session:', error);
@@ -234,16 +255,67 @@ const handleSelectSession = async (sessionId) => {
 // Handle creating new chat from sidebar
 const handleNewChat = async (sessionId = null) => {
   if (sessionId) {
-    // If specific session ID provided, load it
+    // Loading existing session
     await loadChatSession(sessionId);
+    return; // Return early for existing session loading
   } else {
-    // Create a completely new session
-    setMessages([]);
-    setCurrentSessionId(null);
-    setCurrentSessionTitle('');
-    setReplyingTo(null);
-    setThinkingAdvisors([]);
-    setUploadedDocuments([]);
+    // Creating completely new chat with fresh context
+    try {
+      // Step 1: Reset memory session
+      const response = await fetch('http://localhost:8000/new-chat', {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${authToken}`,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          title: `Chat ${new Date().toLocaleDateString()}`
+        })
+      });
+
+      if (response.ok) {
+        const result = await response.json();
+        if (result.status === 'success') {
+          // Step 2: Immediately create MongoDB session
+          const newSessionId = await createNewSession(`Chat ${new Date().toLocaleDateString()}`);
+          
+          if (newSessionId) {
+            // Reset all state to fresh with the new session
+            setMessages([]);
+            setCurrentSessionId(newSessionId); // Set the new session ID immediately
+            setCurrentSessionTitle(`Chat ${new Date().toLocaleDateString()}`);
+            setReplyingTo(null);
+            setThinkingAdvisors([]);
+            setUploadedDocuments([]);
+            
+            console.log('New chat created with MongoDB session:', newSessionId);
+            
+            // Wait a bit to ensure state has updated
+            await new Promise(resolve => setTimeout(resolve, 100));
+            return newSessionId; // Return the session ID for the sidebar
+          } else {
+            throw new Error('Failed to create MongoDB session');
+          }
+        } else {
+          throw new Error('Failed to create memory session');
+        }
+      } else {
+        throw new Error(`HTTP error: ${response.status}`);
+      }
+    } catch (error) {
+      console.error('Error creating new chat:', error);
+      
+      // Fallback to local reset
+      setMessages([]);
+      setCurrentSessionId(null);
+      setCurrentSessionTitle('');
+      setReplyingTo(null);
+      setThinkingAdvisors([]);
+      setUploadedDocuments([]);
+      
+      // Re-throw the error so the sidebar knows something went wrong
+      throw error;
+    }
   }
 };
 
@@ -313,7 +385,8 @@ const handleNewChat = async (sessionId = null) => {
         },
         body: JSON.stringify({
           user_input: inputMessage,
-          response_length: 'medium'
+          response_length: 'medium',
+          chat_session_id: currentSessionId // Include current session ID
         }),
       });
 
@@ -383,78 +456,89 @@ const handleNewChat = async (sessionId = null) => {
   };
 
   const handleReplyToAdvisor = async (inputMessage, replyContext) => {
-    const replyMessage = {
-      id: generateMessageId(),
-      type: 'user',
-      content: inputMessage,
-      replyTo: {
-        advisorId: replyContext.advisorId,
-        advisorName: replyContext.advisorName,
-        messageId: replyContext.messageId
-      },
-      timestamp: new Date()
-    };
+  // Ensure we have a session before proceeding
+  let sessionId = currentSessionId;
+  if (!sessionId) {
+    sessionId = await createNewSession(inputMessage);
+    if (!sessionId) {
+      console.error('Failed to create session for reply');
+      return;
+    }
+  }
 
-    setMessages(prev => [...prev, replyMessage]);
-    
-    // Save reply message to database
-    await saveMessageToSession(replyMessage);
-    
-    setIsLoading(true);
-    setThinkingAdvisors([replyContext.advisorId]);
+  const replyMessage = {
+    id: generateMessageId(),
+    type: 'user',
+    content: inputMessage,
+    replyTo: {
+      advisorId: replyContext.advisorId,
+      advisorName: replyContext.advisorName,
+      messageId: replyContext.messageId
+    },
+    timestamp: new Date()
+  };
 
-    try {
-      const response = await fetch('http://localhost:8000/reply-to-advisor', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          user_input: inputMessage,
-          advisor_id: replyContext.advisorId,
-          original_message_id: replyContext.messageId
-        }),
-      });
+  setMessages(prev => [...prev, replyMessage]);
+  
+  // Save reply message to database with explicit session ID
+  await saveMessageToSession(replyMessage, sessionId);
+  
+  setIsLoading(true);
+  setThinkingAdvisors([replyContext.advisorId]);
 
-      if (!response.ok) {
-        throw new Error(`HTTP error! Status: ${response.status}`);
-      }
+  try {
+    const response = await fetch('http://localhost:8000/reply-to-advisor', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        user_input: inputMessage,
+        advisor_id: replyContext.advisorId,
+        original_message_id: replyContext.messageId,
+        chat_session_id: sessionId // Use confirmed session ID
+      }),
+    });
 
-      const data = await response.json();
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
 
-      if (data.type === 'advisor_reply') {
-        const replyResponseMessage = {
-          id: generateMessageId(),
-          type: 'advisor',
-          advisorId: data.persona_id,
-          advisorName: data.persona,
-          content: data.response,
-          isReply: true,
-          timestamp: new Date()
-        };
-        setMessages(prev => [...prev, replyResponseMessage]);
-        
-        // Save advisor reply to database
-        await saveMessageToSession(replyResponseMessage);
-      }
+    const data = await response.json();
 
-    } catch (error) {
-      console.error('Error replying to advisor:', error);
-      const errorMessage = {
+    if (data.type === 'advisor_reply') {
+      const replyResponseMessage = {
         id: generateMessageId(),
-        type: 'error',
-        content: 'Sorry, I encountered an error with your reply. Please try again.',
+        type: 'advisor',
+        advisorId: data.persona_id,
+        advisorName: data.persona,
+        content: data.response,
+        isReply: true,
         timestamp: new Date()
       };
-      setMessages(prev => [...prev, errorMessage]);
+      setMessages(prev => [...prev, replyResponseMessage]);
       
-      // Save error message to database
-      await saveMessageToSession(errorMessage);
+      // Save advisor reply to database
+      await saveMessageToSession(replyResponseMessage, sessionId);
     }
 
-    setIsLoading(false);
-    setThinkingAdvisors([]);
-  };
+  } catch (error) {
+    console.error('Error replying to advisor:', error);
+    const errorMessage = {
+      id: generateMessageId(),
+      type: 'error',
+      content: 'Sorry, I encountered an error with your reply. Please try again.',
+      timestamp: new Date()
+    };
+    setMessages(prev => [...prev, errorMessage]);
+    
+    // Save error message to database
+    await saveMessageToSession(errorMessage, sessionId);
+  }
+
+  setIsLoading(false);
+  setThinkingAdvisors([]);
+};
 
   const handleCopyMessage = (messageId, content) => {
     // Optional: Show a toast notification or add to message history

phd-advisor-frontend/src/styles/Sidebar.css

@@ -513,6 +513,56 @@
   margin-left: 8px;
 }
 
+.new-chat-button:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+.collapsed-new-chat:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+.loading-sessions {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  padding: 16px;
+  color: var(--text-secondary);
+  font-size: 14px;
+}
+
+.loading-spinner {
+  width: 16px;
+  height: 16px;
+  border: 2px solid var(--border-color);
+  border-top: 2px solid var(--primary-color);
+  border-radius: 50%;
+  animation: spin 1s linear infinite;
+}
+
+@keyframes spin {
+  0% { transform: rotate(0deg); }
+  100% { transform: rotate(360deg); }
+}
+
+/* Style for creating new chat state */
+.new-chat-button span {
+  transition: all 0.2s ease;
+}
+
+.new-chat-button:disabled span {
+  opacity: 0.7;
+}
+
+/* Ensure active session remains highlighted during creation */
+.session-item.active {
+  background-color: var(--primary-color);
+  color: white;
+  border-radius: 8px;
+}
+
 .session-menu-button {
   opacity: 0;
   padding: 6px;