Update app.py

app.py

@@ -209,7 +209,7 @@ def get_or_load_session(session_id: str) -> Dict[str, Any]:
 
 async def save_chat_message_safely(session_id: str, role: str, message: str):
     """Save chat messages to MongoDB asynchronously"""
-    if not DB:
+    if DB is None:  # ✅ CORRECT
         return
     try:
         await asyncio.to_thread(
@@ -223,10 +223,10 @@ async def save_chat_message_safely(session_id: str, role: str, message: str):
         )
     except Exception as e:
         logger.error(f"Failed to save chat message for session {session_id}: {e}")
-
+        
 def get_chat_history_safely(session_id: str, limit: int = 50) -> List[Dict[str, Any]]:
     """Get chat history from MongoDB with error handling"""
-    if not DB:
+    if DB is None:  # ✅ CORRECT
         return []
     try:
         chats_cursor = DB.chats.find({"session_id": session_id}).sort("created_at", -1).limit(limit)
@@ -389,11 +389,11 @@ async def get_session_history(session_id: str):
         "chat_history": history,
         "count": len(history)
     }
-
+    
 @app.get("/session/{session_id}/info")
 async def get_session_info(session_id: str):
     """Get session metadata from MongoDB"""
-    if not DB:
+    if DB is None:  # ✅ CORRECT
         raise HTTPException(status_code=503, detail="Database not connected")
     
     session_doc = await asyncio.to_thread(DB.sessions.find_one, {"session_id": session_id})
@@ -413,6 +413,217 @@ async def get_session_info(session_id: str):
         "in_memory": in_memory
     }
 
+@app.get("/debug/sessions/list")
+async def list_all_sessions():
+    """List all sessions in MongoDB to see what session IDs actually exist"""
+    if DB is None:
+        return {"error": "Database not connected"}
+    
+    try:
+        # Get all sessions
+        sessions = list(DB.sessions.find({}, {
+            "session_id": 1, 
+            "filename": 1, 
+            "status": 1, 
+            "created_at": 1,
+            "_id": 0
+        }).sort("created_at", -1).limit(20))
+        
+        # Get total counts
+        total_sessions = DB.sessions.count_documents({})
+        total_chunks = DB.chunks.count_documents({})
+        
+        return {
+            "total_sessions": total_sessions,
+            "total_chunks": total_chunks,
+            "recent_sessions": sessions,
+            "session_ids_only": [s["session_id"] for s in sessions]
+        }
+        
+    except Exception as e:
+        return {"error": f"Failed to list sessions: {str(e)}"}
+
+@app.get("/debug/sessions/search/{partial_id}")
+async def search_sessions_by_partial_id(partial_id: str):
+    """Search for sessions that contain the partial ID"""
+    if DB is None:
+        return {"error": "Database not connected"}
+    
+    try:
+        # Search for sessions containing the partial ID
+        sessions = list(DB.sessions.find({
+            "session_id": {"$regex": partial_id, "$options": "i"}
+        }, {
+            "session_id": 1, 
+            "filename": 1, 
+            "status": 1, 
+            "created_at": 1,
+            "_id": 0
+        }).limit(10))
+        
+        return {
+            "search_term": partial_id,
+            "matches": sessions,
+            "match_count": len(sessions)
+        }
+        
+    except Exception as e:
+        return {"error": f"Search failed: {str(e)}"}
+
+@app.get("/debug/chunks/by-session/{session_id}")
+async def debug_chunks_for_session(session_id: str):
+    """Check if chunks exist for a session ID (maybe the chunks use a different ID format)"""
+    if DB is None:
+        return {"error": "Database not connected"}
+    
+    try:
+        # Check exact match
+        chunks_exact = DB.chunks.count_documents({"session_id": session_id})
+        
+        # Check partial matches (in case of ID truncation)
+        chunks_partial = list(DB.chunks.find({
+            "session_id": {"$regex": session_id[:8], "$options": "i"}  # First 8 chars
+        }, {
+            "session_id": 1,
+            "chunk_id": 1,
+            "_id": 0
+        }).limit(5))
+        
+        # Check if any chunks exist at all
+        sample_chunks = list(DB.chunks.find({}, {
+            "session_id": 1,
+            "_id": 0
+        }).limit(5))
+        
+        return {
+            "searched_session_id": session_id,
+            "chunks_exact_match": chunks_exact,
+            "chunks_partial_matches": chunks_partial,
+            "sample_chunk_session_ids": [c.get("session_id") for c in sample_chunks]
+        }
+        
+    except Exception as e:
+        return {"error": f"Chunk search failed: {str(e)}"}
+
+
+@app.get("/debug/frontend-session")
+async def debug_frontend_session_issue():
+    """General debug info to help identify frontend/backend session ID mismatch"""
+    if DB is None:
+        return {"error": "Database not connected"}
+    
+    try:
+        # Get sample of how session IDs are actually stored
+        sessions_sample = list(DB.sessions.find({}, {
+            "session_id": 1,
+            "_id": 0
+        }).limit(5))
+        
+        chunks_sample = list(DB.chunks.find({}, {
+            "session_id": 1,
+            "_id": 0
+        }).limit(5))
+        
+        # Get session ID patterns
+        session_id_lengths = {}
+        for session in sessions_sample:
+            sid = session.get("session_id", "")
+            length = len(sid)
+            if length not in session_id_lengths:
+                session_id_lengths[length] = []
+            session_id_lengths[length].append(sid)
+        
+        return {
+            "sessions_collection": {
+                "sample_session_ids": [s.get("session_id") for s in sessions_sample],
+                "session_id_lengths": session_id_lengths
+            },
+            "chunks_collection": {
+                "sample_session_ids": [c.get("session_id") for c in chunks_sample]
+            },
+            "analysis": {
+                "frontend_looking_for": "5ca64618-04fb-48c3-bb15-9d06eb720033",
+                "frontend_id_length": len("5ca64618-04fb-48c3-bb15-9d06eb720033"),
+                "frontend_id_format": "UUID with dashes"
+            }
+        }
+        
+    except Exception as e:
+        return {"error": f"Debug failed: {str(e)}"}
+
+@app.get("/debug/session/{session_id}")
+async def debug_session_status(session_id: str):
+    """Enhanced debug endpoint to check session status in MongoDB"""
+    if DB is None:
+        return {"error": "Database not connected"}
+    
+    try:
+        # Check session document
+        session_doc = DB.sessions.find_one({"session_id": session_id})
+        
+        # Check chunks
+        chunks_count = DB.chunks.count_documents({"session_id": session_id})
+        
+        # If exact match fails, try partial matching
+        partial_sessions = []
+        partial_chunks = 0
+        
+        if not session_doc:
+            # Try searching with first 8 characters (common truncation)
+            short_id = session_id[:8] if len(session_id) >= 8 else session_id
+            partial_sessions = list(DB.sessions.find({
+                "session_id": {"$regex": f"^{short_id}", "$options": "i"}
+            }, {"session_id": 1, "filename": 1, "_id": 0}).limit(3))
+            
+            partial_chunks = DB.chunks.count_documents({
+                "session_id": {"$regex": f"^{short_id}", "$options": "i"}
+            })
+        
+        # Sample chunks for debugging
+        sample_chunks = list(DB.chunks.find(
+            {"session_id": session_id}, 
+            {"chunk_id": 1, "content": 1, "embedding": 1, "_id": 0}
+        ).limit(2))
+        
+        # Check if chunks have embeddings
+        chunks_with_embeddings = DB.chunks.count_documents({
+            "session_id": session_id,
+            "embedding": {"$exists": True, "$ne": None}
+        })
+        
+        return {
+            "searched_session_id": session_id,
+            "session_id_length": len(session_id),
+            "exact_match": {
+                "session_exists": session_doc is not None,
+                "session_status": session_doc.get("status") if session_doc else None,
+                "session_filename": session_doc.get("filename") if session_doc else None,
+                "chunks_count": chunks_count,
+                "chunks_with_embeddings": chunks_with_embeddings,
+            },
+            "partial_matches": {
+                "sessions_found": partial_sessions,
+                "chunks_count": partial_chunks
+            },
+            "sample_chunks": [
+                {
+                    "chunk_id": chunk.get("chunk_id"),
+                    "content_length": len(chunk.get("content", "")),
+                    "has_embedding": chunk.get("embedding") is not None
+                }
+                for chunk in sample_chunks
+            ],
+            "in_memory_cache": session_id in SESSION_STORES,
+            "suggestions": [
+                "Check if session was created with different upload service",
+                "Verify frontend is using correct session ID from upload response",
+                "Check if session creation completed successfully"
+            ]
+        }
+        
+    except Exception as e:
+        return {"error": f"Debug failed: {str(e)}"}
+
 @app.delete("/session/{session_id}/cache")
 async def clear_session_cache(session_id: str):
     """Remove session from memory cache (data remains in MongoDB)"""