fix document upload to new chat

multi_llm_chatbot_backend/app/api/routes/chat.py

@@ -153,9 +153,13 @@ async def create_new_chat(
         raise HTTPException(status_code=500, detail="Failed to create new chat")
 
 @router.post("/chat-sequential")
-async def chat_sequential_enhanced(message: ChatMessage, request: Request):
+async def chat_sequential_enhanced(
+    message: ChatMessage, 
+    request: Request,
+    current_user: User = Depends(get_current_active_user)
+):
     """
-    Enhanced sequential chat with proper session management and document access
+    Enhanced sequential chat with proper session management, document access, and intelligent persona ordering
     """
     try:
         # Ensure consistent session ID for document retrieval
@@ -164,59 +168,36 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
             session_id = f"chat_{message.chat_session_id}"
             logger.info(f"Using chat session: {session_id}")
             
-            # Ensure session exists in memory (load if needed)
+            # FIXED: Ensure session exists in memory (load if needed)
             if session_id not in session_manager.sessions:
                 logger.warning(f"Chat session {message.chat_session_id} not in memory, loading now")
-                # Load the session using the async utility function
-                memory_session_id = await get_or_create_session_for_request_async(
-                    request,
+                
+                # FIXED: Pass the user_id parameter to properly load existing session
+                loaded_session_id = await get_or_create_session_for_request_async(
+                    request, 
                     chat_session_id=message.chat_session_id,
-                    user_id="system"  # This might need proper user ID from auth
+                    user_id=str(current_user.id)
                 )
-                session_id = memory_session_id
+                
+                # Use the loaded session ID
+                session_id = loaded_session_id
+                logger.info(f"Loaded session from database: {session_id}")
         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
-            )
-            logger.info(f"Using new/existing session: {session_id}")
-        
-        # Get the session
+            # No specific chat session, create/use ephemeral session
+            session_id = await get_or_create_session_for_request_async(request)
+            logger.info(f"Using ephemeral session: {session_id}")
+
+        # Get session from memory
         session = session_manager.get_session(session_id)
         
-        # Debug document access
+        # Log session debugging info
         rag_stats = session.get_rag_stats()
         logger.info(f"Session {session_id} has {rag_stats.get('total_documents', 0)} documents available")
         
-        # Debug logging
-        user_messages_count = len([msg for msg in session.messages if msg.get('role') == 'user'])
-        logger.info(f"Session {session_id} has {user_messages_count} user messages before processing")
-        logger.info(f"Input to analyze: '{message.user_input}'")
-        
-        # Check if this needs clarification BEFORE adding the message
-        needs_clarification = chat_orchestrator._needs_clarification(session, message.user_input)
-        
-        logger.info(f"Clarification needed: {needs_clarification}")
-        
-        # Add user message to session for context (after clarification check)
+        # Add user message to session (needed for persona ranking)
         session.append_message("user", message.user_input)
         
-        if needs_clarification:
-            # Generate clarification question
-            clarification_question = await chat_orchestrator._generate_clarification_question(session)
-            
-            logger.info(f"Clarification needed for session {session_id}: '{message.user_input}'")
-            
-            return {
-                "type": "clarification_needed",
-                "message": clarification_question,
-                "suggestions": chat_orchestrator._get_clarification_suggestions(),
-                "session_id": session_id,
-                "chat_session_id": message.chat_session_id  # Include for frontend
-            }
-        
-        # No clarification needed - proceed with intelligent persona ordering
+        # RESTORED: Get intelligently ordered personas based on context
         top_personas = await chat_orchestrator.get_top_personas(
             session_id=session_id, 
             k=3  # Limit to top 3 most relevant personas
@@ -224,15 +205,14 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
         
         logger.info(f"Intelligent persona order for session {session_id}: {top_personas}")
         
-        # Generate responses from ONLY the top 3 personas
+        # Generate responses from ONLY the top personas
         responses = []
         
         for persona_id in top_personas:
             try:
-                # Pass the consistent session_id for document retrieval
                 logger.info(f"Generating response for {persona_id} with session {session_id}")
                 
-                # Generate response from this persona
+                # Generate response from this specific persona
                 persona_result = await chat_orchestrator.chat_with_persona(
                     user_input=message.user_input,
                     persona_id=persona_id,
@@ -240,19 +220,52 @@ async def chat_sequential_enhanced(message: ChatMessage, request: Request):
                     response_length=message.response_length or "medium"
                 )
                 
-                if "persona_name" in persona_result and "response" in persona_result:
-                    responses.append({
-                        "persona": persona_result["persona_name"],
-                        "persona_id": persona_result["persona_id"],
-                        "response": persona_result["response"],
-                        "used_documents": persona_result.get("used_documents", False),
-                        "document_chunks_used": persona_result.get("document_chunks_used", 0)
-                    })
+                # FIXED: Safe response processing with proper error handling
+                if isinstance(persona_result, dict):
+                    # Handle different response formats
+                    if "persona_name" in persona_result and "response" in persona_result:
+                        responses.append({
+                            "persona_id": persona_result["persona_id"],
+                            "persona_name": persona_result["persona_name"], 
+                            "content": persona_result["response"],
+                            "used_documents": persona_result.get("used_documents", False),
+                            "document_chunks_used": persona_result.get("document_chunks_used", 0)
+                        })
+                    elif persona_result.get("type") == "single_persona_response" and "persona" in persona_result:
+                        persona_data = persona_result["persona"]
+                        responses.append({
+                            "persona_id": persona_data["persona_id"],
+                            "persona_name": persona_data["persona_name"],
+                            "content": persona_data["response"],
+                            "used_documents": persona_data.get("used_documents", False),
+                            "document_chunks_used": persona_data.get("document_chunks_used", 0)
+                        })
+                    elif "error" in persona_result:
+                        # Handle error responses
+                        responses.append({
+                            "persona_id": persona_id,
+                            "persona_name": chat_orchestrator.personas[persona_id].name,
+                            "content": persona_result["response"],
+                            "used_documents": False,
+                            "document_chunks_used": 0
+                        })
+                    else:
+                        # Generic dict response
+                        content = persona_result.get("response") or persona_result.get("content", "")
+                        if content.strip():
+                            responses.append({
+                                "persona_id": persona_id,
+                                "persona_name": chat_orchestrator.personas[persona_id].name,
+                                "content": content,
+                                "used_documents": persona_result.get("used_documents", False),
+                                "document_chunks_used": persona_result.get("document_chunks_used", 0)
+                            })
                 else:
+                    # Fallback for non-dict responses
                     responses.append({
-                        "persona": chat_orchestrator.personas[persona_id].name,
                         "persona_id": persona_id,
-                        "response": "I'm having trouble processing your question right now. Please try again.",
+                        "persona_name": chat_orchestrator.personas[persona_id].name,
+                        "content": "I'm having trouble processing your question right now. Please try again.",
                         "used_documents": False,
                         "document_chunks_used": 0
                     })
@@ -260,39 +273,30 @@ 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)}")
                 responses.append({
-                    "persona": chat_orchestrator.personas[persona_id].name,
                     "persona_id": persona_id,
-                    "response": "I encountered an error while processing your question. Please try again.",
+                    "persona_name": chat_orchestrator.personas[persona_id].name,
+                    "content": "I encountered an error while processing your question. Please try again.",
                     "used_documents": False,
                     "document_chunks_used": 0
                 })
         
-        # Include document access info in response
         return {
-            "type": "sequential_responses",
             "responses": responses,
-            "session_id": session_id,
-            "chat_session_id": message.chat_session_id,
-            "document_info": {
-                "total_documents": rag_stats.get('total_documents', 0),
-                "total_chunks": rag_stats.get('total_chunks', 0),
-                "documents": rag_stats.get('documents', [])
+            "session_debug": {
+                "session_id": session_id,
+                "documents_available": rag_stats.get('total_documents', 0),
+                "chunks_available": rag_stats.get('total_chunks', 0),
+                "valid_responses": len(responses),
+                "selected_personas": top_personas,
+                "total_personas_available": len(chat_orchestrator.personas)
             }
         }
-
+        
     except Exception as e:
-        logger.error(f"Error in enhanced sequential chat: {str(e)}")
-        return {
-            "type": "error", 
-            "responses": [{
-                "persona": "System",
-                "response": "I'm having trouble processing your request. Could you please try again?",
-                "used_documents": False,
-                "document_chunks_used": 0
-            }],
-            "session_id": session_id if 'session_id' in locals() else None,
-            "chat_session_id": message.chat_session_id if hasattr(message, 'chat_session_id') else None
-        }
+        logger.error(f"Error in chat_sequential_enhanced: {e}")
+        import traceback
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        raise HTTPException(status_code=500, detail=f"Chat processing failed: {str(e)}")
 
 
 @router.post("/chat/{persona_id}")

multi_llm_chatbot_backend/app/api/routes/documents.py

@@ -157,7 +157,8 @@ def convert_messages_for_export(messages):
 async def upload_document(
     file: UploadFile = File(...), 
     request: Request = None,
-    chat_session_id: str = Query(None, description="Chat session ID if uploading to specific chat")
+    chat_session_id: str = Query(None, description="Chat session ID if uploading to specific chat"),
+    current_user: User = Depends(get_current_active_user)  # ADDED: Require authentication
 ):
     try:
         if chat_session_id:
@@ -166,9 +167,14 @@ async def upload_document(
             logger.info(f"Uploading document to specific chat session: {session_id}")
         else:
             # For new/temporary chats, use regular session management
-            session_id = await get_or_create_session_for_request_async(request)  # FIXED: Added await
+            session_id = await get_or_create_session_for_request_async(request)
             logger.info(f"Uploading document to new session: {session_id}")
         
+        # Add debug logging to track session IDs
+        logger.info(f"Document upload - chat_session_id parameter: {chat_session_id}")
+        logger.info(f"Document upload - final session_id: {session_id}")
+        logger.info(f"Document upload - user_id: {current_user.id}")
+        
         session = session_manager.get_session(session_id)
 
         MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
@@ -193,7 +199,7 @@ async def upload_document(
         rag_result = rag_manager.add_document(
             content=content,
             filename=file.filename,
-            session_id=session_id,  # This now uses the consistent format
+            session_id=session_id,
             file_type=file_type
         )
 
@@ -220,8 +226,9 @@ async def upload_document(
             "total_tokens": rag_result['total_tokens'],
             "file_type": file_type,
             "can_reference_by_name": True,
-            "session_id": session_id,  # Include session ID for debugging
-            "chat_session_id": chat_session_id  # Include original chat session ID
+            "session_id": session_id,
+            "chat_session_id": chat_session_id,
+            "user_id": str(current_user.id)  # ADDED: Include user ID for debugging
         }
 
     except HTTPException:

multi_llm_chatbot_backend/app/api/utils.py

@@ -8,78 +8,94 @@ import logging
 logger = logging.getLogger(__name__)
 session_manager = get_session_manager()
 
-async def load_chat_session_into_context(chat_session_id: str, user_id: str) -> Optional[str]:
+async def load_chat_session_into_context(chat_session_id: str, user_id: str) -> str:
     """
-    Load a MongoDB chat session into in-memory context
-    Returns the in-memory session_id to use
+    Load a chat session from MongoDB into memory context - ENHANCED DEBUG VERSION
     """
     try:
         db = get_database()
         
-        # Get the chat session from MongoDB
+        # Add enhanced debugging
+        logger.info(f"=== LOADING CHAT SESSION DEBUG ===")
+        logger.info(f"Attempting to load chat_session_id: {chat_session_id}")
+        logger.info(f"For user_id: {user_id}")
+        
+        # Try to find the session with enhanced debugging
         chat_session = await db.chat_sessions.find_one({
             "_id": ObjectId(chat_session_id),
-            "user_id": user_id,
-            "is_active": True
+            "user_id": ObjectId(user_id),
+            "deleted_at": {"$exists": False}
         })
         
         if not chat_session:
             logger.warning(f"Chat session {chat_session_id} not found for user {user_id}")
+            
+            # Debug: Check if session exists for any user
+            try:
+                session_exists = await db.chat_sessions.find_one({"_id": ObjectId(chat_session_id)})
+                if session_exists:
+                    logger.warning(f"Session exists but for different user: {session_exists.get('user_id')}")
+                    logger.warning(f"Expected user: {user_id}")
+                    logger.warning(f"Session user: {session_exists.get('user_id')}")
+                    logger.warning(f"User ID types - Expected: {type(user_id)}, Found: {type(session_exists.get('user_id'))}")
+                else:
+                    logger.warning(f"Session {chat_session_id} does not exist in database at all")
+            except Exception as debug_error:
+                logger.error(f"Error during session debug: {debug_error}")
+            
+            # Debug: List recent sessions for this user
+            try:
+                recent_sessions = await db.chat_sessions.find(
+                    {"user_id": ObjectId(user_id), "deleted_at": {"$exists": False}}
+                ).limit(5).to_list(5)
+                logger.info(f"Recent sessions for user {user_id}: {[str(s['_id']) for s in recent_sessions]}")
+            except Exception as debug_error:
+                logger.error(f"Error listing recent sessions: {debug_error}")
+            
             return None
+
+        logger.info(f"✅ Found chat session: {chat_session.get('title', 'Untitled')}")
+        logger.info(f"✅ Message count: {len(chat_session.get('messages', []))}")
         
-        # Create or get in-memory session with a unique ID based on chat session
+        # Create consistent memory session ID  
         memory_session_id = f"chat_{chat_session_id}"
+        logger.info(f"✅ Creating memory session: {memory_session_id}")
+        
+        # Get session manager and create memory session
+        session_manager = get_session_manager()
         memory_session = session_manager.get_session(memory_session_id)
         
-        # Clear existing messages and load from MongoDB
-        memory_session.clear_messages()
+        # Clear any existing data
+        memory_session.clear_all_data()
         
-        # 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)
+        # Load messages into memory session
+        messages = chat_session.get('messages', [])
+        for msg_data in messages:
+            try:
+                message = {
+                    'id': msg_data.get('id', 'unknown'),
+                    'role': 'user' if msg_data.get('type') == 'user' else 'assistant',
+                    'content': msg_data.get('content', ''),
+                    'timestamp': msg_data.get('timestamp', '')
+                }
+                memory_session.append_message(message['role'], message['content'])
+                
+                # Store original message for export
+                if not hasattr(memory_session, 'original_messages'):
+                    memory_session.original_messages = []
+                
+                memory_session.original_messages.append(message)
+            except Exception as msg_error:
+                logger.error(f"Error loading message: {msg_error}")
+                continue
         
         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}")
+        import traceback
+        logger.error(f"Full traceback: {traceback.format_exc()}")
         return None
 
 async def get_or_create_session_for_request_async(