added many new features

app/api/v1/conversation_routes.py

@@ -1,3 +1,9 @@
+# ============================================================================
+# backend/app/api/v1/conversation_routes.py
+# ============================================================================
+
+
+
 """
 Conversation & Chat API Endpoints (UNIFIED)
 
@@ -23,7 +29,7 @@ from app.models.conversation import (
     UpdateConversationRequest,
     ConversationResponse,
     ConversationListResult,
-    Message
+    ReactToMessageRequest  # 🆕 NEW
 )
 
 
@@ -505,6 +511,132 @@ async def get_conversation_stats(
         )
 
 
+# ========================================================================
+# 🆕 NEW ENDPOINTS - Add at bottom before health check
+# ========================================================================
+
+@router.post("/conversation/{conversation_id}/message/{message_index}/react")
+async def react_to_message(
+    conversation_id: str,
+    message_index: int,
+    request: ReactToMessageRequest,
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    👍👎 React to a message.
+    
+    - message_index: Index of message in conversation (0-based)
+    - reaction: 'like' or 'dislike'
+    
+    Replaces existing reaction if user reacts again.
+    User must own the conversation.
+    """
+    try:
+        # Get conversation
+        conversation = await conversation_service.get_conversation(
+            conversation_id=conversation_id,
+            user_id=current_user.user_id
+        )
+        
+        if not conversation:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Conversation not found or access denied"
+            )
+        
+        # Validate message index
+        if message_index < 0 or message_index >= len(conversation.messages):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Invalid message index. Conversation has {len(conversation.messages)} messages."
+            )
+        
+        # Can only react to assistant messages
+        message = conversation.messages[message_index]
+        if message.role != 'assistant':
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Can only react to assistant messages"
+            )
+        
+        # Update reaction in MongoDB
+        await conversation_repository.update_message_reaction(
+            conversation_id=conversation_id,
+            message_index=message_index,
+            reaction=request.reaction
+        )
+        
+        return {
+            "message": "Reaction updated successfully",
+            "conversation_id": conversation_id,
+            "message_index": message_index,
+            "reaction": request.reaction
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"❌ React to message error: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to update reaction: {str(e)}"
+        )
+
+
+@router.delete("/conversation/{conversation_id}/message/{message_index}/react")
+async def remove_reaction(
+    conversation_id: str,
+    message_index: int,
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    ❌ Remove reaction from a message.
+    
+    User must own the conversation.
+    """
+    try:
+        # Get conversation
+        conversation = await conversation_service.get_conversation(
+            conversation_id=conversation_id,
+            user_id=current_user.user_id
+        )
+        
+        if not conversation:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Conversation not found or access denied"
+            )
+        
+        # Validate message index
+        if message_index < 0 or message_index >= len(conversation.messages):
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail=f"Invalid message index"
+            )
+        
+        # Remove reaction in MongoDB
+        await conversation_repository.update_message_reaction(
+            conversation_id=conversation_id,
+            message_index=message_index,
+            reaction=None  # Remove reaction
+        )
+        
+        return {
+            "message": "Reaction removed successfully",
+            "conversation_id": conversation_id,
+            "message_index": message_index
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"❌ Remove reaction error: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to remove reaction: {str(e)}"
+        )
+
+
 # ============================================================================
 # HEALTH CHECK
 # ============================================================================

app/api/v1/file_routes.py

@@ -0,0 +1,134 @@
+from fastapi import APIRouter, UploadFile, File, Depends, HTTPException
+from typing import Dict, Any
+from app.services.file_service import file_service
+from app.utils.dependencies import get_current_user
+from app.models.user import TokenData
+
+router = APIRouter(prefix="/files", tags=["Files"])
+
+
+@router.post("/upload/image", response_model=Dict[str, Any])
+async def upload_image(
+    file: UploadFile = File(..., description="Image file (JPG, PNG, WEBP)"),
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    📷 Upload image with OCR text extraction.
+    
+    - Extracts text from image using Tesseract OCR
+    - Saves file to user's folder
+    - Max size: 10MB
+    """
+    try:
+        result = await file_service.process_image(file, current_user.user_id)
+        return {"success": True, "data": result}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"Image upload failed: {str(e)}")
+
+
+@router.post("/upload/pdf", response_model=Dict[str, Any])
+async def upload_pdf(
+    file: UploadFile = File(..., description="PDF document"),
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    📄 Upload PDF with text extraction.
+    
+    - Extracts all text from PDF pages
+    - Returns page count
+    - Max size: 10MB
+    """
+    try:
+        result = await file_service.process_pdf(file, current_user.user_id)
+        return {"success": True, "data": result}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"PDF upload failed: {str(e)}")
+
+
+@router.post("/upload/document", response_model=Dict[str, Any])
+async def upload_document(
+    file: UploadFile = File(..., description="DOCX or TXT file"),
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    📝 Upload DOCX or TXT document.
+    
+    - Extracts text content
+    - Supports DOCX and TXT formats
+    - Max size: 10MB
+    """
+    try:
+        if file.content_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+            result = await file_service.process_docx(file, current_user.user_id)
+        elif file.content_type == "text/plain":
+            result = await file_service.process_text_file(file, current_user.user_id)
+        else:
+            raise HTTPException(400, "Unsupported document type. Use DOCX or TXT.")
+        
+        return {"success": True, "data": result}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"Document upload failed: {str(e)}")
+
+
+@router.post("/upload/audio", response_model=Dict[str, Any])
+async def upload_audio(
+    file: UploadFile = File(..., description="Audio file (MP3, WAV, WEBM, OGG, M4A)"),
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    🎤 Transcribe audio to text using OpenAI Whisper.
+    
+    - Supports MP3, WAV, WEBM, OGG, M4A
+    - Returns full transcription
+    - Max size: 10MB
+    - Requires OPENAI_API_KEY in environment
+    """
+    try:
+        result = await file_service.transcribe_audio(file, current_user.user_id)
+        return {"success": True, "data": result}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"Audio transcription failed: {str(e)}")
+
+
+@router.delete("/delete")
+async def delete_file(
+    file_path: str,
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    🗑️ Delete uploaded file.
+    
+    - Requires file_path (relative path from upload dir)
+    - User can only delete their own files
+    """
+    try:
+        success = file_service.delete_file(file_path, current_user.user_id)
+        if not success:
+            raise HTTPException(404, "File not found or access denied")
+        return {"success": True, "message": "File deleted successfully"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(500, f"File deletion failed: {str(e)}")
+
+
+@router.get("/health")
+async def file_service_health():
+    """🏥 Health check for file service"""
+    return {
+        "status": "healthy",
+        "service": "file_upload",
+        "supported_formats": {
+            "images": ["JPG", "PNG", "WEBP"],
+            "documents": ["PDF", "DOCX", "TXT"],
+            "audio": ["MP3", "WAV", "WEBM", "OGG", "M4A"]
+        }
+    }

app/config.py

@@ -1,3 +1,8 @@
+# ============================================================================
+# backend/app/config.py
+# ============================================================================
+
+
 """
 Application Configuration
 Settings for Banking RAG Chatbot with JWT Authentication
@@ -49,6 +54,15 @@ class Settings:
     # Model names for Groq (using correct GroqCloud naming)
     GROQ_CHAT_MODEL: str = os.getenv("GROQ_CHAT_MODEL", "llama-3.1-8b-instant")  # For chat interface
     GROQ_EVAL_MODEL: str = os.getenv("GROQ_EVAL_MODEL", "llama-3.3-70b-versatile")  # For evaluation
+
+    # ========================================================================
+    # FILE UPLOAD SETTINGS
+    # ========================================================================
+    UPLOAD_DIR: str = os.getenv("UPLOAD_DIR", "./uploads")
+    MAX_UPLOAD_SIZE: int = 10 * 1024 * 1024  # 10MB
+
+    # OpenAI Whisper API (for audio transcription)
+    # OPENAI_API_KEY: str = os.getenv("OPENAI_API_KEY", "")
     
     # ========================================================================
     # Commented as of now, can be re-enabled if rate limiting is needed

app/db/repositories/backup_conversation_repository.py

@@ -0,0 +1,995 @@
+# """
+# Conversation Repository - MongoDB CRUD operations
+# Handles storing and retrieving conversations from MongoDB Atlas
+
+# Repository Pattern: Separates database logic from business logic
+# This makes code cleaner and easier to test
+
+# Collections:
+# - conversations: Stores complete conversations with messages
+# - retrieval_logs: Logs each retrieval operation (for RL training data)
+# """
+
+# import uuid
+# from datetime import datetime
+# from typing import List, Dict, Optional
+# from bson import ObjectId
+
+# from app.db.mongodb import get_database
+
+
+# # ============================================================================
+# # CONVERSATION REPOSITORY
+# # ============================================================================
+
+# class ConversationRepository:
+#     """
+#     Repository for conversation data in MongoDB.
+    
+#     Provides CRUD operations for:
+#     1. Conversations (user chat sessions)
+#     2. Retrieval logs (for RL training and analytics)
+#     """
+    
+#     def __init__(self):
+#         """
+#         Initialize repository with database connection.
+        
+#         Gracefully handles case where MongoDB is not connected.
+#         """
+#         self.db = get_database()
+        
+#         # Graceful handling if MongoDB not connected
+#         if self.db is None:
+#             print("⚠️ ConversationRepository: MongoDB not connected")
+#             print("   Repository will not function until database is connected")
+#             self.conversations = None
+#             self.retrieval_logs = None
+#         else:
+#             self.conversations = self.db["conversations"]
+#             self.retrieval_logs = self.db["retrieval_logs"]
+#             print("✅ ConversationRepository initialized with MongoDB")
+    
+#     def _check_connection(self):
+#         """
+#         Check if MongoDB is connected.
+        
+#         Raises:
+#             RuntimeError: If MongoDB is not connected
+#         """
+#         if self.db is None or self.conversations is None:
+#             raise RuntimeError(
+#                 "MongoDB not connected. Cannot perform database operations. "
+#                 "Check MONGODB_URI in .env file."
+#             )
+    
+#     # ========================================================================
+#     # CONVERSATION CRUD OPERATIONS
+#     # ========================================================================
+    
+#     async def create_conversation(
+#         self,
+#         user_id: str,
+#         conversation_id: Optional[str] = None
+#     ) -> str:
+#         """
+#         Create a new conversation.
+        
+#         Args:
+#             user_id: User ID who owns this conversation
+#             conversation_id: Optional custom conversation ID (auto-generated if None)
+        
+#         Returns:
+#             str: Conversation ID
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
+#         """
+#         self._check_connection()
+        
+#         if conversation_id is None:
+#             conversation_id = str(uuid.uuid4())
+        
+#         conversation = {
+#             "conversation_id": conversation_id,
+#             "user_id": user_id,
+#             "messages": [],  # Will store all messages
+#             "created_at": datetime.now(),
+#             "updated_at": datetime.now(),
+#             "status": "active"  # active, archived, deleted
+#         }
+        
+#         await self.conversations.insert_one(conversation)
+        
+#         return conversation_id
+    
+#     async def get_conversation(self, conversation_id: str) -> Optional[Dict]:
+#         """
+#         Get a conversation by ID.
+        
+#         Args:
+#             conversation_id: Conversation ID
+        
+#         Returns:
+#             dict or None: Conversation document
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
+#         """
+#         self._check_connection()
+        
+#         conversation = await self.conversations.find_one(
+#             {"conversation_id": conversation_id}
+#         )
+        
+#         # Convert MongoDB ObjectId to string for JSON serialization
+#         if conversation and "_id" in conversation:
+#             conversation["_id"] = str(conversation["_id"])
+        
+#         return conversation
+    
+#     # async def get_user_conversations(
+#     #     self,
+#     #     user_id: str,
+#     #     limit: int = 10,
+#     #     skip: int = 0
+#     # ) -> List[Dict]:
+#     #     """
+#     #     Get all conversations for a user.
+        
+#     #     Args:
+#     #         user_id: User ID
+#     #         limit: Maximum number of conversations to return
+#     #         skip: Number of conversations to skip (for pagination)
+        
+#     #     Returns:
+#     #         list: List of conversation documents
+        
+#     #     Raises:
+#     #         RuntimeError: If MongoDB not connected
+#     #     """
+#     #     self._check_connection()
+        
+#     #     cursor = self.conversations.find(
+#     #         {"user_id": user_id, "status": "active"}
+#     #     ).sort("updated_at", -1).skip(skip).limit(limit)
+        
+#     #     conversations = await cursor.to_list(length=limit)
+        
+#     #     # Convert ObjectIds to strings
+#     #     for conv in conversations:
+#     #         if "_id" in conv:
+#     #             conv["_id"] = str(conv["_id"])
+        
+#     #     return conversations
+#     async def get_user_conversations(
+#         self,
+#         user_id: str,
+#         limit: int = 10,
+#         skip: int = 0
+#     ) -> List[Dict]:
+#         """Get all conversations for a user."""
+#         # Gracefully return empty list if not connected
+#         if self.db is None or self.conversations is None:
+#             print("⚠️  MongoDB not connected - returning empty conversations list")
+#             return []
+    
+#         cursor = self.conversations.find(
+#             {"user_id": user_id, "status": "active"}
+#         ).sort("updated_at", -1).skip(skip).limit(limit)
+    
+#         conversations = await cursor.to_list(length=limit)
+    
+#         # Convert ObjectIds to strings
+#         for conv in conversations:
+#             if "_id" in conv:
+#                 conv["_id"] = str(conv["_id"])
+    
+#         return conversations
+
+    
+#     async def add_message(
+#         self,
+#         conversation_id: str,
+#         message: Dict
+#     ) -> bool:
+#         """
+#         Add a message to a conversation.
+        
+#         Args:
+#             conversation_id: Conversation ID
+#             message: Message dict
+#                 {
+#                     'role': 'user' or 'assistant',
+#                     'content': str,
+#                     'timestamp': datetime,
+#                     'metadata': dict (optional - policy_action, docs_retrieved, etc.)
+#                 }
+        
+#         Returns:
+#             bool: Success status
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
+#         """
+#         self._check_connection()
+        
+#         # Ensure timestamp exists
+#         if "timestamp" not in message:
+#             message["timestamp"] = datetime.now()
+        
+#         # Add message to conversation
+#         result = await self.conversations.update_one(
+#             {"conversation_id": conversation_id},
+#             {
+#                 "$push": {"messages": message},
+#                 "$set": {"updated_at": datetime.now()}
+#             }
+#         )
+        
+#         return result.modified_count > 0
+    
+#     async def get_conversation_history(
+#         self,
+#         conversation_id: str,
+#         max_messages: int = None
+#     ) -> List[Dict]:
+#         """
+#         Get conversation history (messages only).
+        
+#         Args:
+#             conversation_id: Conversation ID
+#             max_messages: Optional limit on number of messages
+        
+#         Returns:
+#             list: List of messages
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
+#         """
+#         self._check_connection()
+        
+#         conversation = await self.get_conversation(conversation_id)
+        
+#         if not conversation:
+#             return []
+        
+#         messages = conversation.get("messages", [])
+        
+#         if max_messages:
+#             messages = messages[-max_messages:]
+        
+#         return messages
+    
+#     async def delete_conversation(self, conversation_id: str) -> bool:
+#         """
+#         Soft delete a conversation (mark as deleted, don't actually delete).
+        
+#         Args:
+#             conversation_id: Conversation ID
+        
+#         Returns:
+#             bool: Success status
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
+#         """
+#         self._check_connection()
+        
+#         result = await self.conversations.update_one(
+#             {"conversation_id": conversation_id},
+#             {
+#                 "$set": {
+#                     "status": "deleted",
+#                     "deleted_at": datetime.now()
+#                 }
+#             }
+#         )
+        
+#         return result.modified_count > 0
+    
+#     # ========================================================================
+#     # RETRIEVAL LOGS (for RL training)
+#     # ========================================================================
+    
+#     async def log_retrieval(
+#         self,
+#         log_data: Dict
+#     ) -> str:
+#         """
+#         Log a retrieval operation (for RL training and analysis).
+        
+#         Args:
+#             log_data: Log data dict
+#                 {
+#                     'conversation_id': str,
+#                     'user_id': str,
+#                     'query': str,
+#                     'policy_action': 'FETCH' or 'NO_FETCH',
+#                     'policy_confidence': float,
+#                     'documents_retrieved': int,
+#                     'top_doc_score': float or None,
+#                     'retrieved_docs_metadata': list,
+#                     'response': str,
+#                     'retrieval_time_ms': float,
+#                     'generation_time_ms': float,
+#                     'total_time_ms': float,
+#                     'timestamp': datetime
+#                 }
+        
+#         Returns:
+#             str: Log ID
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
+#         """
+#         self._check_connection()
+        
+#         # Add timestamp if not present
+#         if "timestamp" not in log_data:
+#             log_data["timestamp"] = datetime.now()
+        
+#         # Generate log ID
+#         log_id = str(uuid.uuid4())
+#         log_data["log_id"] = log_id
+        
+#         # Insert log
+#         await self.retrieval_logs.insert_one(log_data)
+        
+#         return log_id
+    
+#     async def get_retrieval_logs(
+#         self,
+#         conversation_id: Optional[str] = None,
+#         user_id: Optional[str] = None,
+#         limit: int = 100,
+#         skip: int = 0
+#     ) -> List[Dict]:
+#         """
+#         Get retrieval logs (for analysis and RL training).
+        
+#         Args:
+#             conversation_id: Optional filter by conversation
+#             user_id: Optional filter by user
+#             limit: Maximum number of logs
+#             skip: Number of logs to skip
+        
+#         Returns:
+#             list: List of log documents
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
+#         """
+#         self._check_connection()
+        
+#         # Build query
+#         query = {}
+#         if conversation_id:
+#             query["conversation_id"] = conversation_id
+#         if user_id:
+#             query["user_id"] = user_id
+        
+#         # Fetch logs
+#         cursor = self.retrieval_logs.find(query).sort("timestamp", -1).skip(skip).limit(limit)
+#         logs = await cursor.to_list(length=limit)
+        
+#         # Convert ObjectIds to strings
+#         for log in logs:
+#             if "_id" in log:
+#                 log["_id"] = str(log["_id"])
+        
+#         return logs
+    
+#     async def get_logs_for_rl_training(
+#         self,
+#         min_date: Optional[datetime] = None,
+#         limit: int = 1000
+#     ) -> List[Dict]:
+#         """
+#         Get logs specifically for RL training.
+#         Filters for logs with both policy decision and retrieval results.
+        
+#         Args:
+#             min_date: Optional minimum date for logs
+#             limit: Maximum number of logs
+        
+#         Returns:
+#             list: List of log documents suitable for RL training
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
+#         """
+#         self._check_connection()
+        
+#         # Build query
+#         query = {
+#             "policy_action": {"$exists": True},
+#             "response": {"$exists": True}
+#         }
+        
+#         if min_date:
+#             query["timestamp"] = {"$gte": min_date}
+        
+#         # Fetch logs
+#         cursor = self.retrieval_logs.find(query).sort("timestamp", -1).limit(limit)
+#         logs = await cursor.to_list(length=limit)
+        
+#         # Convert ObjectIds
+#         for log in logs:
+#             if "_id" in log:
+#                 log["_id"] = str(log["_id"])
+        
+#         return logs
+    
+#     # ========================================================================
+#     # ANALYTICS QUERIES
+#     # ========================================================================
+    
+#     async def get_conversation_stats(self, user_id: str) -> Dict:
+#         """
+#         Get conversation statistics for a user.
+        
+#         Args:
+#             user_id: User ID
+        
+#         Returns:
+#             dict: Statistics
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
+#         """
+#         self._check_connection()
+        
+#         # Count total conversations
+#         total_conversations = await self.conversations.count_documents({
+#             "user_id": user_id,
+#             "status": "active"
+#         })
+        
+#         # Count total messages
+#         pipeline = [
+#             {"$match": {"user_id": user_id, "status": "active"}},
+#             {"$project": {"message_count": {"$size": "$messages"}}}
+#         ]
+        
+#         result = await self.conversations.aggregate(pipeline).to_list(length=None)
+#         total_messages = sum(doc.get("message_count", 0) for doc in result)
+        
+#         return {
+#             "total_conversations": total_conversations,
+#             "total_messages": total_messages,
+#             "avg_messages_per_conversation": total_messages / total_conversations if total_conversations > 0 else 0
+#         }
+    
+#     async def get_policy_stats(self, user_id: Optional[str] = None) -> Dict:
+#         """
+#         Get policy decision statistics.
+        
+#         Args:
+#             user_id: Optional user ID filter
+        
+#         Returns:
+#             dict: Policy statistics
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
+#         """
+#         self._check_connection()
+        
+#         # Build query
+#         query = {}
+#         if user_id:
+#             query["user_id"] = user_id
+        
+#         # Count FETCH vs NO_FETCH
+#         fetch_count = await self.retrieval_logs.count_documents({
+#             **query,
+#             "policy_action": "FETCH"
+#         })
+        
+#         no_fetch_count = await self.retrieval_logs.count_documents({
+#             **query,
+#             "policy_action": "NO_FETCH"
+#         })
+        
+#         total = fetch_count + no_fetch_count
+        
+#         return {
+#             "fetch_count": fetch_count,
+#             "no_fetch_count": no_fetch_count,
+#             "total": total,
+#             "fetch_rate": fetch_count / total if total > 0 else 0,
+#             "no_fetch_rate": no_fetch_count / total if total > 0 else 0
+#         }
+
+
+# # ============================================================================
+# # USAGE EXAMPLE (for reference)
+# # ============================================================================
+# """
+# # In your service or API endpoint:
+
+# from app.db.repositories.conversation_repository import ConversationRepository
+
+# repo = ConversationRepository()
+
+# # Create conversation
+# conv_id = await repo.create_conversation(user_id="user_123")
+
+# # Add user message
+# await repo.add_message(conv_id, {
+#     'role': 'user',
+#     'content': 'What is my balance?',
+#     'timestamp': datetime.now()
+# })
+
+# # Add assistant message
+# await repo.add_message(conv_id, {
+#     'role': 'assistant',
+#     'content': 'Your balance is $1000',
+#     'timestamp': datetime.now(),
+#     'metadata': {
+#         'policy_action': 'FETCH',
+#         'documents_retrieved': 3
+#     }
+# })
+
+# # Get conversation history
+# history = await repo.get_conversation_history(conv_id)
+
+# # Log retrieval for RL training
+# await repo.log_retrieval({
+#     'conversation_id': conv_id,
+#     'user_id': 'user_123',
+#     'query': 'What is my balance?',
+#     'policy_action': 'FETCH',
+#     'documents_retrieved': 3,
+#     'response': 'Your balance is $1000'
+# })
+# """
+
+
+
+
+
+
+
+# """
+# Conversation Repository - MongoDB CRUD operations
+# Handles storing and retrieving conversations from MongoDB Atlas
+
+# Repository Pattern: Separates database logic from business logic
+# This makes code cleaner and easier to test
+# """
+
+# import uuid
+# from datetime import datetime
+# from typing import List, Dict, Optional
+# from bson import ObjectId
+
+# from app.db.mongodb import get_database
+
+
+# # ============================================================================
+# # CONVERSATION REPOSITORY
+# # ============================================================================
+
+# class ConversationRepository:
+#     """
+#     Repository for conversation data in MongoDB.
+    
+#     Collections used:
+#     - conversations: Stores complete conversations with messages
+#     - retrieval_logs: Logs each retrieval operation (for RL training)
+#     """
+    
+#     def __init__(self):
+#         """Initialize repository with database connection"""
+#         self.db = get_database()
+#         self.conversations = self.db["conversations"]
+#         self.retrieval_logs = self.db["retrieval_logs"]
+    
+#     # ========================================================================
+#     # CONVERSATION CRUD OPERATIONS
+#     # ========================================================================
+    
+#     async def create_conversation(
+#         self,
+#         user_id: str,
+#         conversation_id: Optional[str] = None
+#     ) -> str:
+#         """
+#         Create a new conversation.
+        
+#         Args:
+#             user_id: User ID who owns this conversation
+#             conversation_id: Optional custom conversation ID (auto-generated if None)
+        
+#         Returns:
+#             str: Conversation ID
+#         """
+#         if conversation_id is None:
+#             conversation_id = str(uuid.uuid4())
+        
+#         conversation = {
+#             "conversation_id": conversation_id,
+#             "user_id": user_id,
+#             "messages": [],  # Will store all messages
+#             "created_at": datetime.now(),
+#             "updated_at": datetime.now(),
+#             "status": "active"  # active, archived, deleted
+#         }
+        
+#         await self.conversations.insert_one(conversation)
+        
+#         return conversation_id
+    
+#     async def get_conversation(self, conversation_id: str) -> Optional[Dict]:
+#         """
+#         Get a conversation by ID.
+        
+#         Args:
+#             conversation_id: Conversation ID
+        
+#         Returns:
+#             dict or None: Conversation document
+#         """
+#         conversation = await self.conversations.find_one(
+#             {"conversation_id": conversation_id}
+#         )
+        
+#         # Convert MongoDB ObjectId to string for JSON serialization
+#         if conversation and "_id" in conversation:
+#             conversation["_id"] = str(conversation["_id"])
+        
+#         return conversation
+    
+#     async def get_user_conversations(
+#         self,
+#         user_id: str,
+#         limit: int = 10,
+#         skip: int = 0
+#     ) -> List[Dict]:
+#         """
+#         Get all conversations for a user.
+        
+#         Args:
+#             user_id: User ID
+#             limit: Maximum number of conversations to return
+#             skip: Number of conversations to skip (for pagination)
+        
+#         Returns:
+#             list: List of conversation documents
+#         """
+#         cursor = self.conversations.find(
+#             {"user_id": user_id, "status": "active"}
+#         ).sort("updated_at", -1).skip(skip).limit(limit)
+        
+#         conversations = await cursor.to_list(length=limit)
+        
+#         # Convert ObjectIds to strings
+#         for conv in conversations:
+#             if "_id" in conv:
+#                 conv["_id"] = str(conv["_id"])
+        
+#         return conversations
+    
+#     async def add_message(
+#         self,
+#         conversation_id: str,
+#         message: Dict
+#     ) -> bool:
+#         """
+#         Add a message to a conversation.
+        
+#         Args:
+#             conversation_id: Conversation ID
+#             message: Message dict
+#                 {
+#                     'role': 'user' or 'assistant',
+#                     'content': str,
+#                     'timestamp': datetime,
+#                     'metadata': dict (optional - policy_action, docs_retrieved, etc.)
+#                 }
+        
+#         Returns:
+#             bool: Success status
+#         """
+#         # Ensure timestamp exists
+#         if "timestamp" not in message:
+#             message["timestamp"] = datetime.now()
+        
+#         # Add message to conversation
+#         result = await self.conversations.update_one(
+#             {"conversation_id": conversation_id},
+#             {
+#                 "$push": {"messages": message},
+#                 "$set": {"updated_at": datetime.now()}
+#             }
+#         )
+        
+#         return result.modified_count > 0
+    
+#     async def get_conversation_history(
+#         self,
+#         conversation_id: str,
+#         max_messages: int = None
+#     ) -> List[Dict]:
+#         """
+#         Get conversation history (messages only).
+        
+#         Args:
+#             conversation_id: Conversation ID
+#             max_messages: Optional limit on number of messages
+        
+#         Returns:
+#             list: List of messages
+#         """
+#         conversation = await self.get_conversation(conversation_id)
+        
+#         if not conversation:
+#             return []
+        
+#         messages = conversation.get("messages", [])
+        
+#         if max_messages:
+#             messages = messages[-max_messages:]
+        
+#         return messages
+    
+#     async def delete_conversation(self, conversation_id: str) -> bool:
+#         """
+#         Soft delete a conversation (mark as deleted, don't actually delete).
+        
+#         Args:
+#             conversation_id: Conversation ID
+        
+#         Returns:
+#             bool: Success status
+#         """
+#         result = await self.conversations.update_one(
+#             {"conversation_id": conversation_id},
+#             {
+#                 "$set": {
+#                     "status": "deleted",
+#                     "deleted_at": datetime.now()
+#                 }
+#             }
+#         )
+        
+#         return result.modified_count > 0
+    
+#     # ========================================================================
+#     # RETRIEVAL LOGS (for RL training)
+#     # ========================================================================
+    
+#     async def log_retrieval(
+#         self,
+#         log_data: Dict
+#     ) -> str:
+#         """
+#         Log a retrieval operation (for RL training and analysis).
+        
+#         Args:
+#             log_data: Log data dict
+#                 {
+#                     'conversation_id': str,
+#                     'user_id': str,
+#                     'query': str,
+#                     'policy_action': 'FETCH' or 'NO_FETCH',
+#                     'policy_confidence': float,
+#                     'documents_retrieved': int,
+#                     'top_doc_score': float or None,
+#                     'retrieved_docs_metadata': list,
+#                     'response': str,
+#                     'retrieval_time_ms': float,
+#                     'generation_time_ms': float,
+#                     'total_time_ms': float,
+#                     'timestamp': datetime
+#                 }
+        
+#         Returns:
+#             str: Log ID
+#         """
+#         # Add timestamp if not present
+#         if "timestamp" not in log_data:
+#             log_data["timestamp"] = datetime.now()
+        
+#         # Generate log ID
+#         log_id = str(uuid.uuid4())
+#         log_data["log_id"] = log_id
+        
+#         # Insert log
+#         await self.retrieval_logs.insert_one(log_data)
+        
+#         return log_id
+    
+#     async def get_retrieval_logs(
+#         self,
+#         conversation_id: Optional[str] = None,
+#         user_id: Optional[str] = None,
+#         limit: int = 100,
+#         skip: int = 0
+#     ) -> List[Dict]:
+#         """
+#         Get retrieval logs (for analysis and RL training).
+        
+#         Args:
+#             conversation_id: Optional filter by conversation
+#             user_id: Optional filter by user
+#             limit: Maximum number of logs
+#             skip: Number of logs to skip
+        
+#         Returns:
+#             list: List of log documents
+#         """
+#         # Build query
+#         query = {}
+#         if conversation_id:
+#             query["conversation_id"] = conversation_id
+#         if user_id:
+#             query["user_id"] = user_id
+        
+#         # Fetch logs
+#         cursor = self.retrieval_logs.find(query).sort("timestamp", -1).skip(skip).limit(limit)
+#         logs = await cursor.to_list(length=limit)
+        
+#         # Convert ObjectIds to strings
+#         for log in logs:
+#             if "_id" in log:
+#                 log["_id"] = str(log["_id"])
+        
+#         return logs
+    
+#     async def get_logs_for_rl_training(
+#         self,
+#         min_date: Optional[datetime] = None,
+#         limit: int = 1000
+#     ) -> List[Dict]:
+#         """
+#         Get logs specifically for RL training.
+#         Filters for logs with both policy decision and retrieval results.
+        
+#         Args:
+#             min_date: Optional minimum date for logs
+#             limit: Maximum number of logs
+        
+#         Returns:
+#             list: List of log documents suitable for RL training
+#         """
+#         # Build query
+#         query = {
+#             "policy_action": {"$exists": True},
+#             "response": {"$exists": True}
+#         }
+        
+#         if min_date:
+#             query["timestamp"] = {"$gte": min_date}
+        
+#         # Fetch logs
+#         cursor = self.retrieval_logs.find(query).sort("timestamp", -1).limit(limit)
+#         logs = await cursor.to_list(length=limit)
+        
+#         # Convert ObjectIds
+#         for log in logs:
+#             if "_id" in log:
+#                 log["_id"] = str(log["_id"])
+        
+#         return logs
+    
+#     # ========================================================================
+#     # ANALYTICS QUERIES
+#     # ========================================================================
+    
+#     async def get_conversation_stats(self, user_id: str) -> Dict:
+#         """
+#         Get conversation statistics for a user.
+        
+#         Args:
+#             user_id: User ID
+        
+#         Returns:
+#             dict: Statistics
+#         """
+#         # Count total conversations
+#         total_conversations = await self.conversations.count_documents({
+#             "user_id": user_id,
+#             "status": "active"
+#         })
+        
+#         # Count total messages
+#         pipeline = [
+#             {"$match": {"user_id": user_id, "status": "active"}},
+#             {"$project": {"message_count": {"$size": "$messages"}}}
+#         ]
+        
+#         result = await self.conversations.aggregate(pipeline).to_list(length=None)
+#         total_messages = sum(doc.get("message_count", 0) for doc in result)
+        
+#         return {
+#             "total_conversations": total_conversations,
+#             "total_messages": total_messages,
+#             "avg_messages_per_conversation": total_messages / total_conversations if total_conversations > 0 else 0
+#         }
+    
+#     async def get_policy_stats(self, user_id: Optional[str] = None) -> Dict:
+#         """
+#         Get policy decision statistics.
+        
+#         Args:
+#             user_id: Optional user ID filter
+        
+#         Returns:
+#             dict: Policy statistics
+#         """
+#         # Build query
+#         query = {}
+#         if user_id:
+#             query["user_id"] = user_id
+        
+#         # Count FETCH vs NO_FETCH
+#         fetch_count = await self.retrieval_logs.count_documents({
+#             **query,
+#             "policy_action": "FETCH"
+#         })
+        
+#         no_fetch_count = await self.retrieval_logs.count_documents({
+#             **query,
+#             "policy_action": "NO_FETCH"
+#         })
+        
+#         total = fetch_count + no_fetch_count
+        
+#         return {
+#             "fetch_count": fetch_count,
+#             "no_fetch_count": no_fetch_count,
+#             "total": total,
+#             "fetch_rate": fetch_count / total if total > 0 else 0,
+#             "no_fetch_rate": no_fetch_count / total if total > 0 else 0
+#         }
+
+
+# # ============================================================================
+# # USAGE EXAMPLE (for reference)
+# # ============================================================================
+# """
+# # In your service or API endpoint:
+
+# from app.db.repositories.conversation_repository import ConversationRepository
+
+# repo = ConversationRepository()
+
+# # Create conversation
+# conv_id = await repo.create_conversation(user_id="user_123")
+
+# # Add user message
+# await repo.add_message(conv_id, {
+#     'role': 'user',
+#     'content': 'What is my balance?',
+#     'timestamp': datetime.now()
+# })
+
+# # Add assistant message
+# await repo.add_message(conv_id, {
+#     'role': 'assistant',
+#     'content': 'Your balance is $1000',
+#     'timestamp': datetime.now(),
+#     'metadata': {
+#         'policy_action': 'FETCH',
+#         'documents_retrieved': 3
+#     }
+# })
+
+# # Get conversation history
+# history = await repo.get_conversation_history(conv_id)
+
+# # Log retrieval for RL training
+# await repo.log_retrieval({
+#     'conversation_id': conv_id,
+#     'user_id': 'user_123',
+#     'query': 'What is my balance?',
+#     'policy_action': 'FETCH',
+#     'documents_retrieved': 3,
+#     'response': 'Your balance is $1000'
+# })
+# """

app/db/repositories/conversation_repository.py

@@ -1,3 +1,8 @@
+# ============================================================================
+# backend/app/db/repositories/conversation_repository.py
+# ============================================================================
+
+
 """
 Conversation Repository - MongoDB Operations (UPDATED)
 
@@ -16,7 +21,6 @@ from pymongo import DESCENDING, ASCENDING
 from app.db.mongodb import get_database
 from app.models.conversation import (
     Conversation,
-    Message,
     ConversationListResponse,
     ConversationListResult
 )
@@ -576,1007 +580,56 @@ class ConversationRepository:
         
         except Exception as e:
             print(f"⚠️ Failed to create indexes: {e}")
+    # ============================================================================
+    # ADD TO: backend/app/db/repositories/conversation_repository.py
+    # Add this method to ConversationRepository class
+    # ============================================================================
 
-
-# ============================================================================
-# GLOBAL REPOSITORY INSTANCE
-# ============================================================================
-
-conversation_repository = ConversationRepository()
-
-
-# """
-# Conversation Repository - MongoDB CRUD operations
-# Handles storing and retrieving conversations from MongoDB Atlas
-
-# Repository Pattern: Separates database logic from business logic
-# This makes code cleaner and easier to test
-
-# Collections:
-# - conversations: Stores complete conversations with messages
-# - retrieval_logs: Logs each retrieval operation (for RL training data)
-# """
-
-# import uuid
-# from datetime import datetime
-# from typing import List, Dict, Optional
-# from bson import ObjectId
-
-# from app.db.mongodb import get_database
-
-
-# # ============================================================================
-# # CONVERSATION REPOSITORY
-# # ============================================================================
-
-# class ConversationRepository:
-#     """
-#     Repository for conversation data in MongoDB.
-    
-#     Provides CRUD operations for:
-#     1. Conversations (user chat sessions)
-#     2. Retrieval logs (for RL training and analytics)
-#     """
-    
-#     def __init__(self):
-#         """
-#         Initialize repository with database connection.
-        
-#         Gracefully handles case where MongoDB is not connected.
-#         """
-#         self.db = get_database()
-        
-#         # Graceful handling if MongoDB not connected
-#         if self.db is None:
-#             print("⚠️ ConversationRepository: MongoDB not connected")
-#             print("   Repository will not function until database is connected")
-#             self.conversations = None
-#             self.retrieval_logs = None
-#         else:
-#             self.conversations = self.db["conversations"]
-#             self.retrieval_logs = self.db["retrieval_logs"]
-#             print("✅ ConversationRepository initialized with MongoDB")
-    
-#     def _check_connection(self):
-#         """
-#         Check if MongoDB is connected.
-        
-#         Raises:
-#             RuntimeError: If MongoDB is not connected
-#         """
-#         if self.db is None or self.conversations is None:
-#             raise RuntimeError(
-#                 "MongoDB not connected. Cannot perform database operations. "
-#                 "Check MONGODB_URI in .env file."
-#             )
-    
-#     # ========================================================================
-#     # CONVERSATION CRUD OPERATIONS
-#     # ========================================================================
-    
-#     async def create_conversation(
-#         self,
-#         user_id: str,
-#         conversation_id: Optional[str] = None
-#     ) -> str:
-#         """
-#         Create a new conversation.
-        
-#         Args:
-#             user_id: User ID who owns this conversation
-#             conversation_id: Optional custom conversation ID (auto-generated if None)
-        
-#         Returns:
-#             str: Conversation ID
-        
-#         Raises:
-#             RuntimeError: If MongoDB not connected
-#         """
-#         self._check_connection()
-        
-#         if conversation_id is None:
-#             conversation_id = str(uuid.uuid4())
-        
-#         conversation = {
-#             "conversation_id": conversation_id,
-#             "user_id": user_id,
-#             "messages": [],  # Will store all messages
-#             "created_at": datetime.now(),
-#             "updated_at": datetime.now(),
-#             "status": "active"  # active, archived, deleted
-#         }
-        
-#         await self.conversations.insert_one(conversation)
-        
-#         return conversation_id
-    
-#     async def get_conversation(self, conversation_id: str) -> Optional[Dict]:
-#         """
-#         Get a conversation by ID.
-        
-#         Args:
-#             conversation_id: Conversation ID
-        
-#         Returns:
-#             dict or None: Conversation document
-        
-#         Raises:
-#             RuntimeError: If MongoDB not connected
-#         """
-#         self._check_connection()
-        
-#         conversation = await self.conversations.find_one(
-#             {"conversation_id": conversation_id}
-#         )
-        
-#         # Convert MongoDB ObjectId to string for JSON serialization
-#         if conversation and "_id" in conversation:
-#             conversation["_id"] = str(conversation["_id"])
-        
-#         return conversation
-    
-#     # async def get_user_conversations(
-#     #     self,
-#     #     user_id: str,
-#     #     limit: int = 10,
-#     #     skip: int = 0
-#     # ) -> List[Dict]:
-#     #     """
-#     #     Get all conversations for a user.
-        
-#     #     Args:
-#     #         user_id: User ID
-#     #         limit: Maximum number of conversations to return
-#     #         skip: Number of conversations to skip (for pagination)
-        
-#     #     Returns:
-#     #         list: List of conversation documents
-        
-#     #     Raises:
-#     #         RuntimeError: If MongoDB not connected
-#     #     """
-#     #     self._check_connection()
-        
-#     #     cursor = self.conversations.find(
-#     #         {"user_id": user_id, "status": "active"}
-#     #     ).sort("updated_at", -1).skip(skip).limit(limit)
-        
-#     #     conversations = await cursor.to_list(length=limit)
-        
-#     #     # Convert ObjectIds to strings
-#     #     for conv in conversations:
-#     #         if "_id" in conv:
-#     #             conv["_id"] = str(conv["_id"])
-        
-#     #     return conversations
-#     async def get_user_conversations(
-#         self,
-#         user_id: str,
-#         limit: int = 10,
-#         skip: int = 0
-#     ) -> List[Dict]:
-#         """Get all conversations for a user."""
-#         # Gracefully return empty list if not connected
-#         if self.db is None or self.conversations is None:
-#             print("⚠️  MongoDB not connected - returning empty conversations list")
-#             return []
-    
-#         cursor = self.conversations.find(
-#             {"user_id": user_id, "status": "active"}
-#         ).sort("updated_at", -1).skip(skip).limit(limit)
-    
-#         conversations = await cursor.to_list(length=limit)
-    
-#         # Convert ObjectIds to strings
-#         for conv in conversations:
-#             if "_id" in conv:
-#                 conv["_id"] = str(conv["_id"])
-    
-#         return conversations
-
-    
-#     async def add_message(
-#         self,
-#         conversation_id: str,
-#         message: Dict
-#     ) -> bool:
-#         """
-#         Add a message to a conversation.
-        
-#         Args:
-#             conversation_id: Conversation ID
-#             message: Message dict
-#                 {
-#                     'role': 'user' or 'assistant',
-#                     'content': str,
-#                     'timestamp': datetime,
-#                     'metadata': dict (optional - policy_action, docs_retrieved, etc.)
-#                 }
-        
-#         Returns:
-#             bool: Success status
-        
-#         Raises:
-#             RuntimeError: If MongoDB not connected
-#         """
-#         self._check_connection()
-        
-#         # Ensure timestamp exists
-#         if "timestamp" not in message:
-#             message["timestamp"] = datetime.now()
-        
-#         # Add message to conversation
-#         result = await self.conversations.update_one(
-#             {"conversation_id": conversation_id},
-#             {
-#                 "$push": {"messages": message},
-#                 "$set": {"updated_at": datetime.now()}
-#             }
-#         )
-        
-#         return result.modified_count > 0
-    
-#     async def get_conversation_history(
-#         self,
-#         conversation_id: str,
-#         max_messages: int = None
-#     ) -> List[Dict]:
-#         """
-#         Get conversation history (messages only).
-        
-#         Args:
-#             conversation_id: Conversation ID
-#             max_messages: Optional limit on number of messages
-        
-#         Returns:
-#             list: List of messages
-        
-#         Raises:
-#             RuntimeError: If MongoDB not connected
-#         """
-#         self._check_connection()
-        
-#         conversation = await self.get_conversation(conversation_id)
-        
-#         if not conversation:
-#             return []
-        
-#         messages = conversation.get("messages", [])
-        
-#         if max_messages:
-#             messages = messages[-max_messages:]
-        
-#         return messages
-    
-#     async def delete_conversation(self, conversation_id: str) -> bool:
-#         """
-#         Soft delete a conversation (mark as deleted, don't actually delete).
-        
-#         Args:
-#             conversation_id: Conversation ID
-        
-#         Returns:
-#             bool: Success status
-        
-#         Raises:
-#             RuntimeError: If MongoDB not connected
-#         """
-#         self._check_connection()
-        
-#         result = await self.conversations.update_one(
-#             {"conversation_id": conversation_id},
-#             {
-#                 "$set": {
-#                     "status": "deleted",
-#                     "deleted_at": datetime.now()
-#                 }
-#             }
-#         )
-        
-#         return result.modified_count > 0
-    
-#     # ========================================================================
-#     # RETRIEVAL LOGS (for RL training)
-#     # ========================================================================
-    
-#     async def log_retrieval(
-#         self,
-#         log_data: Dict
-#     ) -> str:
-#         """
-#         Log a retrieval operation (for RL training and analysis).
-        
-#         Args:
-#             log_data: Log data dict
-#                 {
-#                     'conversation_id': str,
-#                     'user_id': str,
-#                     'query': str,
-#                     'policy_action': 'FETCH' or 'NO_FETCH',
-#                     'policy_confidence': float,
-#                     'documents_retrieved': int,
-#                     'top_doc_score': float or None,
-#                     'retrieved_docs_metadata': list,
-#                     'response': str,
-#                     'retrieval_time_ms': float,
-#                     'generation_time_ms': float,
-#                     'total_time_ms': float,
-#                     'timestamp': datetime
-#                 }
-        
-#         Returns:
-#             str: Log ID
-        
-#         Raises:
-#             RuntimeError: If MongoDB not connected
-#         """
-#         self._check_connection()
-        
-#         # Add timestamp if not present
-#         if "timestamp" not in log_data:
-#             log_data["timestamp"] = datetime.now()
-        
-#         # Generate log ID
-#         log_id = str(uuid.uuid4())
-#         log_data["log_id"] = log_id
-        
-#         # Insert log
-#         await self.retrieval_logs.insert_one(log_data)
-        
-#         return log_id
-    
-#     async def get_retrieval_logs(
-#         self,
-#         conversation_id: Optional[str] = None,
-#         user_id: Optional[str] = None,
-#         limit: int = 100,
-#         skip: int = 0
-#     ) -> List[Dict]:
-#         """
-#         Get retrieval logs (for analysis and RL training).
-        
-#         Args:
-#             conversation_id: Optional filter by conversation
-#             user_id: Optional filter by user
-#             limit: Maximum number of logs
-#             skip: Number of logs to skip
-        
-#         Returns:
-#             list: List of log documents
-        
-#         Raises:
-#             RuntimeError: If MongoDB not connected
-#         """
-#         self._check_connection()
-        
-#         # Build query
-#         query = {}
-#         if conversation_id:
-#             query["conversation_id"] = conversation_id
-#         if user_id:
-#             query["user_id"] = user_id
-        
-#         # Fetch logs
-#         cursor = self.retrieval_logs.find(query).sort("timestamp", -1).skip(skip).limit(limit)
-#         logs = await cursor.to_list(length=limit)
-        
-#         # Convert ObjectIds to strings
-#         for log in logs:
-#             if "_id" in log:
-#                 log["_id"] = str(log["_id"])
-        
-#         return logs
-    
-#     async def get_logs_for_rl_training(
-#         self,
-#         min_date: Optional[datetime] = None,
-#         limit: int = 1000
-#     ) -> List[Dict]:
-#         """
-#         Get logs specifically for RL training.
-#         Filters for logs with both policy decision and retrieval results.
-        
-#         Args:
-#             min_date: Optional minimum date for logs
-#             limit: Maximum number of logs
-        
-#         Returns:
-#             list: List of log documents suitable for RL training
-        
-#         Raises:
-#             RuntimeError: If MongoDB not connected
-#         """
-#         self._check_connection()
-        
-#         # Build query
-#         query = {
-#             "policy_action": {"$exists": True},
-#             "response": {"$exists": True}
-#         }
-        
-#         if min_date:
-#             query["timestamp"] = {"$gte": min_date}
-        
-#         # Fetch logs
-#         cursor = self.retrieval_logs.find(query).sort("timestamp", -1).limit(limit)
-#         logs = await cursor.to_list(length=limit)
-        
-#         # Convert ObjectIds
-#         for log in logs:
-#             if "_id" in log:
-#                 log["_id"] = str(log["_id"])
-        
-#         return logs
-    
-#     # ========================================================================
-#     # ANALYTICS QUERIES
-#     # ========================================================================
-    
-#     async def get_conversation_stats(self, user_id: str) -> Dict:
-#         """
-#         Get conversation statistics for a user.
-        
-#         Args:
-#             user_id: User ID
-        
-#         Returns:
-#             dict: Statistics
-        
-#         Raises:
-#             RuntimeError: If MongoDB not connected
-#         """
-#         self._check_connection()
-        
-#         # Count total conversations
-#         total_conversations = await self.conversations.count_documents({
-#             "user_id": user_id,
-#             "status": "active"
-#         })
-        
-#         # Count total messages
-#         pipeline = [
-#             {"$match": {"user_id": user_id, "status": "active"}},
-#             {"$project": {"message_count": {"$size": "$messages"}}}
-#         ]
-        
-#         result = await self.conversations.aggregate(pipeline).to_list(length=None)
-#         total_messages = sum(doc.get("message_count", 0) for doc in result)
-        
-#         return {
-#             "total_conversations": total_conversations,
-#             "total_messages": total_messages,
-#             "avg_messages_per_conversation": total_messages / total_conversations if total_conversations > 0 else 0
-#         }
-    
-#     async def get_policy_stats(self, user_id: Optional[str] = None) -> Dict:
-#         """
-#         Get policy decision statistics.
-        
-#         Args:
-#             user_id: Optional user ID filter
-        
-#         Returns:
-#             dict: Policy statistics
-        
-#         Raises:
-#             RuntimeError: If MongoDB not connected
-#         """
-#         self._check_connection()
-        
-#         # Build query
-#         query = {}
-#         if user_id:
-#             query["user_id"] = user_id
-        
-#         # Count FETCH vs NO_FETCH
-#         fetch_count = await self.retrieval_logs.count_documents({
-#             **query,
-#             "policy_action": "FETCH"
-#         })
-        
-#         no_fetch_count = await self.retrieval_logs.count_documents({
-#             **query,
-#             "policy_action": "NO_FETCH"
-#         })
-        
-#         total = fetch_count + no_fetch_count
-        
-#         return {
-#             "fetch_count": fetch_count,
-#             "no_fetch_count": no_fetch_count,
-#             "total": total,
-#             "fetch_rate": fetch_count / total if total > 0 else 0,
-#             "no_fetch_rate": no_fetch_count / total if total > 0 else 0
-#         }
-
-
-# # ============================================================================
-# # USAGE EXAMPLE (for reference)
-# # ============================================================================
-# """
-# # In your service or API endpoint:
-
-# from app.db.repositories.conversation_repository import ConversationRepository
-
-# repo = ConversationRepository()
-
-# # Create conversation
-# conv_id = await repo.create_conversation(user_id="user_123")
-
-# # Add user message
-# await repo.add_message(conv_id, {
-#     'role': 'user',
-#     'content': 'What is my balance?',
-#     'timestamp': datetime.now()
-# })
-
-# # Add assistant message
-# await repo.add_message(conv_id, {
-#     'role': 'assistant',
-#     'content': 'Your balance is $1000',
-#     'timestamp': datetime.now(),
-#     'metadata': {
-#         'policy_action': 'FETCH',
-#         'documents_retrieved': 3
-#     }
-# })
-
-# # Get conversation history
-# history = await repo.get_conversation_history(conv_id)
-
-# # Log retrieval for RL training
-# await repo.log_retrieval({
-#     'conversation_id': conv_id,
-#     'user_id': 'user_123',
-#     'query': 'What is my balance?',
-#     'policy_action': 'FETCH',
-#     'documents_retrieved': 3,
-#     'response': 'Your balance is $1000'
-# })
-# """
-
-
-
-
-
-
-
-# """
-# Conversation Repository - MongoDB CRUD operations
-# Handles storing and retrieving conversations from MongoDB Atlas
-
-# Repository Pattern: Separates database logic from business logic
-# This makes code cleaner and easier to test
-# """
-
-# import uuid
-# from datetime import datetime
-# from typing import List, Dict, Optional
-# from bson import ObjectId
-
-# from app.db.mongodb import get_database
-
-
-# # ============================================================================
-# # CONVERSATION REPOSITORY
-# # ============================================================================
-
-# class ConversationRepository:
-#     """
-#     Repository for conversation data in MongoDB.
-    
-#     Collections used:
-#     - conversations: Stores complete conversations with messages
-#     - retrieval_logs: Logs each retrieval operation (for RL training)
-#     """
-    
-#     def __init__(self):
-#         """Initialize repository with database connection"""
-#         self.db = get_database()
-#         self.conversations = self.db["conversations"]
-#         self.retrieval_logs = self.db["retrieval_logs"]
-    
-#     # ========================================================================
-#     # CONVERSATION CRUD OPERATIONS
-#     # ========================================================================
-    
-#     async def create_conversation(
-#         self,
-#         user_id: str,
-#         conversation_id: Optional[str] = None
-#     ) -> str:
-#         """
-#         Create a new conversation.
-        
-#         Args:
-#             user_id: User ID who owns this conversation
-#             conversation_id: Optional custom conversation ID (auto-generated if None)
-        
-#         Returns:
-#             str: Conversation ID
-#         """
-#         if conversation_id is None:
-#             conversation_id = str(uuid.uuid4())
-        
-#         conversation = {
-#             "conversation_id": conversation_id,
-#             "user_id": user_id,
-#             "messages": [],  # Will store all messages
-#             "created_at": datetime.now(),
-#             "updated_at": datetime.now(),
-#             "status": "active"  # active, archived, deleted
-#         }
-        
-#         await self.conversations.insert_one(conversation)
-        
-#         return conversation_id
-    
-#     async def get_conversation(self, conversation_id: str) -> Optional[Dict]:
-#         """
-#         Get a conversation by ID.
-        
-#         Args:
-#             conversation_id: Conversation ID
-        
-#         Returns:
-#             dict or None: Conversation document
-#         """
-#         conversation = await self.conversations.find_one(
-#             {"conversation_id": conversation_id}
-#         )
-        
-#         # Convert MongoDB ObjectId to string for JSON serialization
-#         if conversation and "_id" in conversation:
-#             conversation["_id"] = str(conversation["_id"])
-        
-#         return conversation
-    
-#     async def get_user_conversations(
-#         self,
-#         user_id: str,
-#         limit: int = 10,
-#         skip: int = 0
-#     ) -> List[Dict]:
-#         """
-#         Get all conversations for a user.
-        
-#         Args:
-#             user_id: User ID
-#             limit: Maximum number of conversations to return
-#             skip: Number of conversations to skip (for pagination)
-        
-#         Returns:
-#             list: List of conversation documents
-#         """
-#         cursor = self.conversations.find(
-#             {"user_id": user_id, "status": "active"}
-#         ).sort("updated_at", -1).skip(skip).limit(limit)
-        
-#         conversations = await cursor.to_list(length=limit)
-        
-#         # Convert ObjectIds to strings
-#         for conv in conversations:
-#             if "_id" in conv:
-#                 conv["_id"] = str(conv["_id"])
-        
-#         return conversations
-    
-#     async def add_message(
-#         self,
-#         conversation_id: str,
-#         message: Dict
-#     ) -> bool:
-#         """
-#         Add a message to a conversation.
-        
-#         Args:
-#             conversation_id: Conversation ID
-#             message: Message dict
-#                 {
-#                     'role': 'user' or 'assistant',
-#                     'content': str,
-#                     'timestamp': datetime,
-#                     'metadata': dict (optional - policy_action, docs_retrieved, etc.)
-#                 }
-        
-#         Returns:
-#             bool: Success status
-#         """
-#         # Ensure timestamp exists
-#         if "timestamp" not in message:
-#             message["timestamp"] = datetime.now()
-        
-#         # Add message to conversation
-#         result = await self.conversations.update_one(
-#             {"conversation_id": conversation_id},
-#             {
-#                 "$push": {"messages": message},
-#                 "$set": {"updated_at": datetime.now()}
-#             }
-#         )
-        
-#         return result.modified_count > 0
-    
-#     async def get_conversation_history(
-#         self,
-#         conversation_id: str,
-#         max_messages: int = None
-#     ) -> List[Dict]:
-#         """
-#         Get conversation history (messages only).
-        
-#         Args:
-#             conversation_id: Conversation ID
-#             max_messages: Optional limit on number of messages
-        
-#         Returns:
-#             list: List of messages
-#         """
-#         conversation = await self.get_conversation(conversation_id)
-        
-#         if not conversation:
-#             return []
-        
-#         messages = conversation.get("messages", [])
-        
-#         if max_messages:
-#             messages = messages[-max_messages:]
-        
-#         return messages
-    
-#     async def delete_conversation(self, conversation_id: str) -> bool:
-#         """
-#         Soft delete a conversation (mark as deleted, don't actually delete).
-        
-#         Args:
-#             conversation_id: Conversation ID
-        
-#         Returns:
-#             bool: Success status
-#         """
-#         result = await self.conversations.update_one(
-#             {"conversation_id": conversation_id},
-#             {
-#                 "$set": {
-#                     "status": "deleted",
-#                     "deleted_at": datetime.now()
-#                 }
-#             }
-#         )
-        
-#         return result.modified_count > 0
-    
-#     # ========================================================================
-#     # RETRIEVAL LOGS (for RL training)
-#     # ========================================================================
-    
-#     async def log_retrieval(
-#         self,
-#         log_data: Dict
-#     ) -> str:
-#         """
-#         Log a retrieval operation (for RL training and analysis).
-        
-#         Args:
-#             log_data: Log data dict
-#                 {
-#                     'conversation_id': str,
-#                     'user_id': str,
-#                     'query': str,
-#                     'policy_action': 'FETCH' or 'NO_FETCH',
-#                     'policy_confidence': float,
-#                     'documents_retrieved': int,
-#                     'top_doc_score': float or None,
-#                     'retrieved_docs_metadata': list,
-#                     'response': str,
-#                     'retrieval_time_ms': float,
-#                     'generation_time_ms': float,
-#                     'total_time_ms': float,
-#                     'timestamp': datetime
-#                 }
-        
-#         Returns:
-#             str: Log ID
-#         """
-#         # Add timestamp if not present
-#         if "timestamp" not in log_data:
-#             log_data["timestamp"] = datetime.now()
-        
-#         # Generate log ID
-#         log_id = str(uuid.uuid4())
-#         log_data["log_id"] = log_id
-        
-#         # Insert log
-#         await self.retrieval_logs.insert_one(log_data)
-        
-#         return log_id
-    
-#     async def get_retrieval_logs(
-#         self,
-#         conversation_id: Optional[str] = None,
-#         user_id: Optional[str] = None,
-#         limit: int = 100,
-#         skip: int = 0
-#     ) -> List[Dict]:
-#         """
-#         Get retrieval logs (for analysis and RL training).
-        
-#         Args:
-#             conversation_id: Optional filter by conversation
-#             user_id: Optional filter by user
-#             limit: Maximum number of logs
-#             skip: Number of logs to skip
-        
-#         Returns:
-#             list: List of log documents
-#         """
-#         # Build query
-#         query = {}
-#         if conversation_id:
-#             query["conversation_id"] = conversation_id
-#         if user_id:
-#             query["user_id"] = user_id
-        
-#         # Fetch logs
-#         cursor = self.retrieval_logs.find(query).sort("timestamp", -1).skip(skip).limit(limit)
-#         logs = await cursor.to_list(length=limit)
-        
-#         # Convert ObjectIds to strings
-#         for log in logs:
-#             if "_id" in log:
-#                 log["_id"] = str(log["_id"])
-        
-#         return logs
-    
-#     async def get_logs_for_rl_training(
-#         self,
-#         min_date: Optional[datetime] = None,
-#         limit: int = 1000
-#     ) -> List[Dict]:
-#         """
-#         Get logs specifically for RL training.
-#         Filters for logs with both policy decision and retrieval results.
-        
-#         Args:
-#             min_date: Optional minimum date for logs
-#             limit: Maximum number of logs
-        
-#         Returns:
-#             list: List of log documents suitable for RL training
-#         """
-#         # Build query
-#         query = {
-#             "policy_action": {"$exists": True},
-#             "response": {"$exists": True}
-#         }
-        
-#         if min_date:
-#             query["timestamp"] = {"$gte": min_date}
-        
-#         # Fetch logs
-#         cursor = self.retrieval_logs.find(query).sort("timestamp", -1).limit(limit)
-#         logs = await cursor.to_list(length=limit)
-        
-#         # Convert ObjectIds
-#         for log in logs:
-#             if "_id" in log:
-#                 log["_id"] = str(log["_id"])
-        
-#         return logs
+    async def update_message_reaction(
+        self,
+        conversation_id: str,
+        message_index: int,
+        reaction: Optional[str]
+    ) -> bool:
+        """
+        Update reaction for a specific message.
     
-#     # ========================================================================
-#     # ANALYTICS QUERIES
-#     # ========================================================================
+        Args:
+            conversation_id: Conversation ID
+            message_index: Index of message in messages array (0-based)
+            reaction: 'like', 'dislike', or None (to remove)
     
-#     async def get_conversation_stats(self, user_id: str) -> Dict:
-#         """
-#         Get conversation statistics for a user.
-        
-#         Args:
-#             user_id: User ID
-        
-#         Returns:
-#             dict: Statistics
-#         """
-#         # Count total conversations
-#         total_conversations = await self.conversations.count_documents({
-#             "user_id": user_id,
-#             "status": "active"
-#         })
+        Returns:
+            bool: True if updated
+        """
+        try:
+            from bson import ObjectId
         
-#         # Count total messages
-#         pipeline = [
-#             {"$match": {"user_id": user_id, "status": "active"}},
-#             {"$project": {"message_count": {"$size": "$messages"}}}
-#         ]
+            # Build update query
+            result = await self.collection.update_one(
+                {"_id": ObjectId(conversation_id)},
+                {
+                    "$set": {
+                        f"messages.{message_index}.reaction": reaction,
+                        "updated_at": datetime.utcnow()
+                    }
+                }
+            )
         
-#         result = await self.conversations.aggregate(pipeline).to_list(length=None)
-#         total_messages = sum(doc.get("message_count", 0) for doc in result)
+            if result.modified_count > 0:
+                print(f"✅ Reaction updated for message {message_index}: {reaction}")
+                return True
         
-#         return {
-#             "total_conversations": total_conversations,
-#             "total_messages": total_messages,
-#             "avg_messages_per_conversation": total_messages / total_conversations if total_conversations > 0 else 0
-#         }
+            print(f"⚠️ No message updated (conversation or index not found)")
+            return False
     
-#     async def get_policy_stats(self, user_id: Optional[str] = None) -> Dict:
-#         """
-#         Get policy decision statistics.
-        
-#         Args:
-#             user_id: Optional user ID filter
-        
-#         Returns:
-#             dict: Policy statistics
-#         """
-#         # Build query
-#         query = {}
-#         if user_id:
-#             query["user_id"] = user_id
-        
-#         # Count FETCH vs NO_FETCH
-#         fetch_count = await self.retrieval_logs.count_documents({
-#             **query,
-#             "policy_action": "FETCH"
-#         })
-        
-#         no_fetch_count = await self.retrieval_logs.count_documents({
-#             **query,
-#             "policy_action": "NO_FETCH"
-#         })
-        
-#         total = fetch_count + no_fetch_count
-        
-#         return {
-#             "fetch_count": fetch_count,
-#             "no_fetch_count": no_fetch_count,
-#             "total": total,
-#             "fetch_rate": fetch_count / total if total > 0 else 0,
-#             "no_fetch_rate": no_fetch_count / total if total > 0 else 0
-#         }
-
-
-# # ============================================================================
-# # USAGE EXAMPLE (for reference)
-# # ============================================================================
-# """
-# # In your service or API endpoint:
-
-# from app.db.repositories.conversation_repository import ConversationRepository
-
-# repo = ConversationRepository()
-
-# # Create conversation
-# conv_id = await repo.create_conversation(user_id="user_123")
-
-# # Add user message
-# await repo.add_message(conv_id, {
-#     'role': 'user',
-#     'content': 'What is my balance?',
-#     'timestamp': datetime.now()
-# })
+        except Exception as e:
+            print(f"❌ Update reaction error: {e}")
+            return False
 
-# # Add assistant message
-# await repo.add_message(conv_id, {
-#     'role': 'assistant',
-#     'content': 'Your balance is $1000',
-#     'timestamp': datetime.now(),
-#     'metadata': {
-#         'policy_action': 'FETCH',
-#         'documents_retrieved': 3
-#     }
-# })
 
-# # Get conversation history
-# history = await repo.get_conversation_history(conv_id)
+# ============================================================================
+# GLOBAL REPOSITORY INSTANCE
+# ============================================================================
 
-# # Log retrieval for RL training
-# await repo.log_retrieval({
-#     'conversation_id': conv_id,
-#     'user_id': 'user_123',
-#     'query': 'What is my balance?',
-#     'policy_action': 'FETCH',
-#     'documents_retrieved': 3,
-#     'response': 'Your balance is $1000'
-# })
-# """
+conversation_repository = ConversationRepository()

app/main.py

@@ -1,3 +1,8 @@
+# ============================================================================
+# backend/app/main.py
+# ============================================================================
+
+
 """
 FastAPI Main Application Entry Point (UPDATED)
 
@@ -141,6 +146,7 @@ app.add_middleware(
 
 from app.api.v1 import auth
 from app.api.v1 import conversation_routes  # ✅ NEW IMPORT
+from app.api.v1 import file_routes # new file routes
 
 # Auth router (public endpoints - register, login)
 app.include_router(
@@ -155,6 +161,12 @@ app.include_router(
     prefix="/api/v1/chat",
     tags=["💬 Chat & Conversations"]
 )
+# File Upload router (protected endpoints - requires JWT token)
+app.include_router(
+    file_routes.router,
+    prefix="/api/v1",
+    tags=["📁 File Upload"]
+)
 
 # ============================================================================
 # ROOT ENDPOINTS
@@ -196,6 +208,14 @@ async def root():
                 "search_conversations": "GET /api/v1/chat/conversations/search (requires token)",
                 "conversation_stats": "GET /api/v1/chat/conversations/stats (requires token)"
             },
+            "files": {
+                "upload_image": "POST /api/v1/files/upload/image (requires token)",
+                "upload_pdf": "POST /api/v1/files/upload/pdf (requires token)",
+                "upload_document": "POST /api/v1/files/upload/document (requires token)",
+                "upload_audio": "POST /api/v1/files/upload/audio (requires token)",
+                "delete_file": "DELETE /api/v1/files/delete (requires token)",
+                "health": "GET /api/v1/files/health"
+            },
             "health": "GET /health"
         }
     }

app/models/conversation.py

@@ -1,3 +1,9 @@
+# ============================================================================
+# backend/app/models/conversation.py
+# ============================================================================
+
+
+
 """
 Conversation Models for MongoDB
 
@@ -10,7 +16,7 @@ Handles conversation persistence with:
 
 from datetime import datetime
 from typing import List, Optional, Dict, Any, Annotated
-from pydantic import BaseModel, Field, ConfigDict, field_validator, BeforeValidator
+from pydantic import BaseModel, Field, ConfigDict, BeforeValidator
 from bson import ObjectId
 
 
@@ -275,3 +281,78 @@ class ConversationListResult(BaseModel):
             }
         }
     )
+
+# ============================================================================
+# UPDATE: backend/app/models/conversation.py
+# ADD THIS TO Message CLASS (line ~40)
+# ============================================================================
+
+class Message(BaseModel):
+    """
+    Single message in a conversation.
+    
+    Contains:
+    - User/assistant content
+    - Metadata from RAG pipeline (policy action, retrieval stats)
+    - User reaction (👍 👎)
+    - Timestamp
+    """
+    
+    role: str = Field(..., description="Role: 'user' or 'assistant'")
+    content: str = Field(..., description="Message content")
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+    
+    # Metadata from RAG pipeline (only for assistant messages)
+    metadata: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="RAG metadata: policy_action, confidence, docs_retrieved, etc."
+    )
+    
+    # ========================================================================
+    # 🆕 NEW: User reaction to message
+    # ========================================================================
+    reaction: Optional[str] = Field(
+        default=None,
+        description="User reaction: 'like', 'dislike', or None",
+        pattern="^(like|dislike)$"  # Only allow these values
+    )
+    
+    model_config = ConfigDict(
+        json_encoders={
+            datetime: lambda v: v.isoformat()
+        },
+        json_schema_extra={
+            "example": {
+                "role": "assistant",
+                "content": "Your account balance is $1,234.56",
+                "timestamp": "2024-01-15T10:30:00",
+                "metadata": {
+                    "policy_action": "FETCH",
+                    "confidence": 0.95
+                },
+                "reaction": "like"  # 👍
+            }
+        }
+    )
+
+
+# ============================================================================
+# 🆕 NEW REQUEST MODEL
+# ============================================================================
+
+class ReactToMessageRequest(BaseModel):
+    """Request body for reacting to a message"""
+    
+    reaction: str = Field(
+        ...,
+        description="Reaction type: 'like' or 'dislike'",
+        pattern="^(like|dislike)$"
+    )
+    
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "reaction": "like"
+            }
+        }
+    )

app/services/chat_service.py

@@ -1,3 +1,8 @@
+# ============================================================================
+# backend/app/services/chat_service.py
+# ============================================================================
+
+
 """
 Chat Service - Main RAG Pipeline
 

app/services/conversation_service.py

@@ -1,3 +1,8 @@
+# ============================================================================
+# backend/app/services/conversation_service.py
+# ============================================================================
+
+
 """
 Conversation Service - Business Logic Layer (UPDATED)
 

app/services/file_service.py

@@ -0,0 +1,323 @@
+import os
+from pathlib import Path
+from typing import Optional, Dict, Any
+from fastapi import UploadFile, HTTPException
+import pytesseract
+from PIL import Image
+import PyPDF2
+import docx
+from io import BytesIO
+
+from app.utils.file_utils import (
+    validate_file_type, validate_file_size, generate_unique_filename, 
+    save_upload_file, ALLOWED_IMAGE_TYPES, 
+    # ALLOWED_DOC_TYPES, 
+    ALLOWED_AUDIO_TYPES
+)
+from app.config import settings
+
+
+class FileService:
+    """File processing service for images, PDFs, documents, and audio"""
+    
+    def __init__(self):
+        self.upload_dir = Path(settings.UPLOAD_DIR)
+        self.upload_dir.mkdir(parents=True, exist_ok=True)
+        print("✅ FileService initialized")
+    
+    async def process_image(self, file: UploadFile, user_id: str) -> Dict[str, Any]:
+        """
+        Upload image + OCR extraction.
+        
+        Args:
+            file: Uploaded image file
+            user_id: User ID (for file organization)
+        
+        Returns:
+            Dict with file_id, path, extracted_text, size
+        """
+        if not validate_file_type(file, ALLOWED_IMAGE_TYPES):
+            raise HTTPException(400, "Invalid image type. Allowed: JPG, PNG, WEBP")
+        if not validate_file_size(file):
+            raise HTTPException(400, "File too large (max 10MB)")
+        
+        # Save file
+        filename = generate_unique_filename(file.filename)
+        filepath = self.upload_dir / "images" / user_id / filename
+        await save_upload_file(file, filepath)
+        
+        # OCR extraction
+        try:
+            image = Image.open(filepath)
+            text = pytesseract.image_to_string(image)
+        except Exception as e:
+            print(f"⚠️ OCR failed: {e}")
+            text = ""
+        
+        return {
+            "file_id": filename,
+            "file_path": str(filepath.relative_to(self.upload_dir)),
+            "file_type": "image",
+            "extracted_text": text.strip(),
+            "size": filepath.stat().st_size,
+            "original_filename": file.filename
+        }
+    
+    async def process_pdf(self, file: UploadFile, user_id: str) -> Dict[str, Any]:
+        """
+        Upload PDF + text extraction.
+        
+        Args:
+            file: Uploaded PDF file
+            user_id: User ID
+        
+        Returns:
+            Dict with file_id, path, extracted_text, pages, size
+        """
+        if file.content_type != "application/pdf":
+            raise HTTPException(400, "Invalid PDF file")
+        if not validate_file_size(file):
+            raise HTTPException(400, "File too large (max 10MB)")
+        
+        # Save
+        filename = generate_unique_filename(file.filename)
+        filepath = self.upload_dir / "documents" / user_id / filename
+        await save_upload_file(file, filepath)
+        
+        # Extract text
+        text = ""
+        pages = 0
+        try:
+            with open(filepath, 'rb') as f:
+                pdf_reader = PyPDF2.PdfReader(f)
+                pages = len(pdf_reader.pages)
+                for page in pdf_reader.pages:
+                    text += page.extract_text() + "\n"
+        except Exception as e:
+            print(f"⚠️ PDF extraction failed: {e}")
+        
+        return {
+            "file_id": filename,
+            "file_path": str(filepath.relative_to(self.upload_dir)),
+            "file_type": "pdf",
+            "extracted_text": text.strip(),
+            "pages": pages,
+            "size": filepath.stat().st_size,
+            "original_filename": file.filename
+        }
+    
+    async def process_docx(self, file: UploadFile, user_id: str) -> Dict[str, Any]:
+        """
+        Upload DOCX + text extraction.
+        
+        Args:
+            file: Uploaded DOCX file
+            user_id: User ID
+        
+        Returns:
+            Dict with file_id, path, extracted_text, size
+        """
+        if file.content_type != "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+            raise HTTPException(400, "Invalid DOCX file")
+        if not validate_file_size(file):
+            raise HTTPException(400, "File too large (max 10MB)")
+        
+        # Save
+        filename = generate_unique_filename(file.filename)
+        filepath = self.upload_dir / "documents" / user_id / filename
+        await save_upload_file(file, filepath)
+        
+        # Extract
+        text = ""
+        try:
+            doc = docx.Document(filepath)
+            text = "\n".join([para.text for para in doc.paragraphs])
+        except Exception as e:
+            print(f"⚠️ DOCX extraction failed: {e}")
+        
+        return {
+            "file_id": filename,
+            "file_path": str(filepath.relative_to(self.upload_dir)),
+            "file_type": "docx",
+            "extracted_text": text.strip(),
+            "size": filepath.stat().st_size,
+            "original_filename": file.filename
+        }
+    
+    async def process_text_file(self, file: UploadFile, user_id: str) -> Dict[str, Any]:
+        """
+        Upload TXT file.
+        
+        Args:
+            file: Uploaded text file
+            user_id: User ID
+        
+        Returns:
+            Dict with file_id, path, extracted_text, size
+        """
+        if file.content_type != "text/plain":
+            raise HTTPException(400, "Invalid text file")
+        if not validate_file_size(file):
+            raise HTTPException(400, "File too large (max 10MB)")
+        
+        filename = generate_unique_filename(file.filename)
+        filepath = self.upload_dir / "documents" / user_id / filename
+        await save_upload_file(file, filepath)
+        
+        text = ""
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                text = f.read()
+        except Exception as e:
+            print(f"⚠️ Text file read failed: {e}")
+        
+        return {
+            "file_id": filename,
+            "file_path": str(filepath.relative_to(self.upload_dir)),
+            "file_type": "text",
+            "extracted_text": text.strip(),
+            "size": filepath.stat().st_size,
+            "original_filename": file.filename
+        }
+    
+    # ============================================================================
+    # NEW METHOD: Using HuggingFace Transformers Whisper (FREE!)
+    # ============================================================================
+
+    async def transcribe_audio(self, file: UploadFile, user_id: str) -> Dict[str, Any]:
+        """
+        Speech-to-text using HuggingFace Transformers Whisper (FREE!).
+    
+        Args:
+            file: Uploaded audio file
+            user_id: User ID
+    
+        Returns:
+            Dict with file_id, path, transcription, size
+        """
+        if not validate_file_type(file, ALLOWED_AUDIO_TYPES):
+            raise HTTPException(400, "Invalid audio type. Allowed: MP3, WAV, WEBM, OGG, M4A")
+        if not validate_file_size(file):
+            raise HTTPException(400, "File too large (max 10MB)")
+    
+        # Save audio
+        filename = generate_unique_filename(file.filename)
+        filepath = self.upload_dir / "audio" / user_id / filename
+        await save_upload_file(file, filepath)
+    
+        # Transcribe using HuggingFace Transformers Whisper (FREE!)
+        transcription = ""
+        try:
+            from transformers import pipeline
+            import torch
+        
+            # Lazy load model (only first time)
+            if not hasattr(self, '_whisper_pipe'):
+                print("🎤 Loading Whisper model (one-time)...")
+                device = 0 if torch.cuda.is_available() else -1
+                self._whisper_pipe = pipeline(
+                    "automatic-speech-recognition",
+                    model="openai/whisper-small",  # Small = fast, good accuracy
+                    device=device
+                )
+                print("✅ Whisper model loaded")
+        
+            # Transcribe
+            result = self._whisper_pipe(str(filepath))
+            transcription = result["text"]
+        
+        except Exception as e:
+            print(f"⚠️ Whisper transcription failed: {e}")
+            raise HTTPException(500, f"Transcription failed: {str(e)}")
+    
+        return {
+            "file_id": filename,
+            "file_path": str(filepath.relative_to(self.upload_dir)),
+            "file_type": "audio",
+            "transcription": transcription,
+            "size": filepath.stat().st_size,
+            "original_filename": file.filename
+        }
+
+    # ============================================================================
+    # Old method: OpenAI Whisper API (paid) kept for reference
+    # ============================================================================
+        # async def transcribe_audio(self, file: UploadFile, user_id: str) -> Dict[str, Any]:
+        #     """
+        #     Speech-to-text using OpenAI Whisper API.
+        
+        #     Args:
+        #         file: Uploaded audio file
+        #         user_id: User ID
+        
+        #     Returns:
+        #         Dict with file_id, path, transcription, size
+        #     """
+        #     if not validate_file_type(file, ALLOWED_AUDIO_TYPES):
+        #         raise HTTPException(400, "Invalid audio type. Allowed: MP3, WAV, WEBM, OGG, M4A")
+        #     if not validate_file_size(file):
+        #         raise HTTPException(400, "File too large (max 10MB)")
+
+        #     # Save audio
+        #     filename = generate_unique_filename(file.filename)
+        #     filepath = self.upload_dir / "audio" / user_id / filename
+        #     await save_upload_file(file, filepath)
+
+        #     # Transcribe using OpenAI Whisper API
+        #     transcription = ""
+        #     try:
+        #         from openai import OpenAI
+        #         client = OpenAI(api_key=settings.OPENAI_API_KEY)
+
+        #         with open(filepath, "rb") as audio_file:
+        #             transcript = client.audio.transcriptions.create(
+        #                 model="whisper-1",
+        #                 file=audio_file,
+        #                 language="en"  # Change if needed
+        #             )
+
+        #         transcription = transcript.text
+        #     except Exception as e:
+        #         print(f"⚠️ Whisper transcription failed: {e}")
+        #         raise HTTPException(500, f"Transcription failed: {str(e)}")
+
+        #     return {
+        #         "file_id": filename,
+        #         "file_path": str(filepath.relative_to(self.upload_dir)),
+        #         "file_type": "audio",
+        #         "transcription": transcription,
+        #         "size": filepath.stat().st_size,
+        #         "original_filename": file.filename
+        #     }
+    
+    def delete_file(self, file_path: str, user_id: str) -> bool:
+        """
+        Delete uploaded file.
+        
+        Args:
+            file_path: Relative file path (from upload_dir)
+            user_id: User ID (for security check)
+        
+        Returns:
+            bool: True if deleted
+        """
+        try:
+            # Security: Ensure file belongs to user
+            if user_id not in file_path:
+                return False
+            
+            full_path = self.upload_dir / file_path
+            if full_path.exists() and full_path.is_file():
+                full_path.unlink()
+                return True
+            return False
+        except Exception as e:
+            print(f"⚠️ File deletion failed: {e}")
+            return False
+
+
+# ============================================================================
+# GLOBAL SERVICE INSTANCE
+# ============================================================================
+
+file_service = FileService()

app/utils/file_utils.py

@@ -0,0 +1,35 @@
+import os
+import shutil
+from pathlib import Path
+from typing import Optional
+from fastapi import UploadFile
+import uuid
+
+ALLOWED_IMAGE_TYPES = {"image/jpeg", "image/png", "image/jpg", "image/webp"}
+ALLOWED_DOC_TYPES = {"application/pdf", "application/vnd.openxmlformats-officedocument.wordprocessingml.document", "text/plain"}
+ALLOWED_AUDIO_TYPES = {"audio/mpeg", "audio/wav", "audio/webm", "audio/ogg", "audio/m4a"}
+
+MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+
+def validate_file_type(file: UploadFile, allowed_types: set) -> bool:
+    """Check if file type is allowed"""
+    return file.content_type in allowed_types
+
+def validate_file_size(file: UploadFile, max_size: int = MAX_FILE_SIZE) -> bool:
+    """Check if file size is under limit"""
+    file.file.seek(0, 2)
+    size = file.file.tell()
+    file.file.seek(0)
+    return size <= max_size
+
+def generate_unique_filename(original_filename: str) -> str:
+    """Generate unique filename with UUID"""
+    ext = Path(original_filename).suffix
+    return f"{uuid.uuid4()}{ext}"
+
+async def save_upload_file(file: UploadFile, destination: Path) -> Path:
+    """Save uploaded file to destination"""
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    with destination.open("wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    return destination

requirements.txt

@@ -69,6 +69,7 @@ numpy
 
 # ML/Deep Learning
 torch
+torchaudio
 transformers
 
 
@@ -76,4 +77,12 @@ transformers
 python-jose[cryptography]
 passlib[bcrypt]==1.7.4
 python-multipart
-bcrypt==4.0.1
+bcrypt==4.0.1
+
+# new features dependencies
+python-multipart
+pillow
+pytesseract
+PyPDF2
+python-docx
+pydub