backend changes, added new features

app/api/v1/chat.py

@@ -1,391 +1,3 @@
-"""
-Chat API Endpoints (WITH AUTHENTICATION)
-RESTful API for the Banking RAG Chatbot
-
-NOW REQUIRES JWT TOKEN FOR ALL ENDPOINTS!
-
-Endpoints:
-- POST /chat - Send a message and get response (PROTECTED)
-- GET /chat/history/{conversation_id} - Get conversation history (PROTECTED)
-- POST /chat/conversation - Create new conversation (PROTECTED)
-- GET /chat/conversations - List user's conversations (PROTECTED)
-- DELETE /chat/conversation/{conversation_id} - Delete conversation (PROTECTED)
-- GET /chat/health - Health check (PUBLIC)
-"""
-
-from fastapi import APIRouter, HTTPException, status, Depends
-from pydantic import BaseModel, Field
-from typing import List, Dict, Optional
-from datetime import datetime
-
-from app.services.chat_service import chat_service
-from app.db.repositories.conversation_repository import ConversationRepository
-from app.utils.dependencies import get_current_user  # AUTH DEPENDENCY
-from app.models.user import TokenData  # USER DATA FROM TOKEN
-
-
-# ============================================================================
-# CREATE ROUTER
-# ============================================================================
-router = APIRouter()
-
-
-# ============================================================================
-# DEPENDENCY: Get ConversationRepository instance
-# ============================================================================
-def get_conversation_repo() -> ConversationRepository:
-    """
-    Dependency that provides ConversationRepository instance.
-    This ensures MongoDB is connected before repository is used.
-    """
-    return ConversationRepository()
-
-
-# ============================================================================
-# PYDANTIC MODELS (Request/Response schemas)
-# ============================================================================
-
-class ChatRequest(BaseModel):
-    """Request model for chat endpoint"""
-    query: str = Field(..., description="User query text", min_length=1, max_length=1000)
-    conversation_id: Optional[str] = Field(None, description="Optional conversation ID")
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "query": "What is my account balance?",
-                "conversation_id": "conv-123"
-            }
-        }
-
-
-class ChatResponse(BaseModel):
-    """Response model for chat endpoint"""
-    response: str = Field(..., description="Generated response text")
-    conversation_id: str = Field(..., description="Conversation ID")
-    policy_action: str = Field(..., description="Policy decision: FETCH or NO_FETCH")
-    policy_confidence: float = Field(..., description="Policy confidence score (0-1)")
-    documents_retrieved: int = Field(..., description="Number of documents retrieved")
-    top_doc_score: Optional[float] = Field(None, description="Best document similarity score")
-    total_time_ms: float = Field(..., description="Total processing time in milliseconds")
-    timestamp: str = Field(..., description="Response timestamp (ISO format)")
-
-
-class ConversationCreateResponse(BaseModel):
-    """Response after creating a conversation"""
-    conversation_id: str = Field(..., description="Created conversation ID")
-    created_at: str = Field(..., description="Creation timestamp")
-
-
-class MessageModel(BaseModel):
-    """Single message in conversation history"""
-    role: str = Field(..., description="Message role: user or assistant")
-    content: str = Field(..., description="Message content")
-    timestamp: str = Field(..., description="Message timestamp")
-    metadata: Optional[Dict] = Field(None, description="Optional metadata")
-
-
-class ConversationHistoryResponse(BaseModel):
-    """Response containing conversation history"""
-    conversation_id: str
-    messages: List[MessageModel]
-    message_count: int
-
-
-# ============================================================================
-# ENDPOINTS (ALL PROTECTED WITH JWT)
-# ============================================================================
-
-@router.post("/", response_model=ChatResponse, status_code=status.HTTP_200_OK)
-async def chat(
-    request: ChatRequest,
-    current_user: TokenData = Depends(get_current_user),
-    repo: ConversationRepository = Depends(get_conversation_repo)  # ← INJECT REPO
-):
-    """
-    Main chat endpoint - Send a query and get a response.
-    
-    **REQUIRES AUTHENTICATION** - JWT token must be provided in Authorization header.
-    """
-    try:
-        # Get user_id from token
-        user_id = current_user.user_id
-        
-        # If no conversation_id provided, create a new conversation
-        conversation_id = request.conversation_id
-        if not conversation_id:
-            conversation_id = await repo.create_conversation(user_id=user_id)
-        else:
-            # Verify user owns this conversation
-            conversation = await repo.get_conversation(conversation_id)
-            if not conversation:
-                raise HTTPException(
-                    status_code=status.HTTP_404_NOT_FOUND,
-                    detail="Conversation not found"
-                )
-            if conversation["user_id"] != user_id:
-                raise HTTPException(
-                    status_code=status.HTTP_403_FORBIDDEN,
-                    detail="Access denied - you don't own this conversation"
-                )
-        
-        # Get conversation history
-        history = await repo.get_conversation_history(
-            conversation_id=conversation_id,
-            max_messages=10
-        )
-        
-        # Save user message
-        await repo.add_message(
-            conversation_id=conversation_id,
-            message={
-                'role': 'user',
-                'content': request.query,
-                'timestamp': datetime.now()
-            }
-        )
-        
-        # Process query through RAG pipeline
-        result = await chat_service.process_query(
-            query=request.query,
-            conversation_history=history,
-            user_id=user_id
-        )
-        
-        # Save assistant message
-        await repo.add_message(
-            conversation_id=conversation_id,
-            message={
-                'role': 'assistant',
-                'content': result['response'],
-                'timestamp': datetime.now(),
-                'metadata': {
-                    'policy_action': result['policy_action'],
-                    'policy_confidence': result['policy_confidence'],
-                    'documents_retrieved': result['documents_retrieved'],
-                    'top_doc_score': result['top_doc_score']
-                }
-            }
-        )
-        
-        # Log retrieval data for RL training
-        await repo.log_retrieval({
-            'conversation_id': conversation_id,
-            'user_id': user_id,
-            'query': request.query,
-            'policy_action': result['policy_action'],
-            'policy_confidence': result['policy_confidence'],
-            'should_retrieve': result['should_retrieve'],
-            'documents_retrieved': result['documents_retrieved'],
-            'top_doc_score': result['top_doc_score'],
-            'response': result['response'],
-            'retrieval_time_ms': result['retrieval_time_ms'],
-            'generation_time_ms': result['generation_time_ms'],
-            'total_time_ms': result['total_time_ms'],
-            'retrieved_docs_metadata': result.get('retrieved_docs_metadata', []),
-            'timestamp': datetime.now()
-        })
-        
-        # Return response
-        return ChatResponse(
-            response=result['response'],
-            conversation_id=conversation_id,
-            policy_action=result['policy_action'],
-            policy_confidence=result['policy_confidence'],
-            documents_retrieved=result['documents_retrieved'],
-            top_doc_score=result['top_doc_score'],
-            total_time_ms=result['total_time_ms'],
-            timestamp=result['timestamp']
-        )
-    
-    except HTTPException:
-        raise
-    except Exception as e:
-        print(f"❌ Chat endpoint error: {e}")
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to process chat request: {str(e)}"
-        )
-
-
-@router.post("/conversation", response_model=ConversationCreateResponse, status_code=status.HTTP_201_CREATED)
-async def create_conversation(
-    current_user: TokenData = Depends(get_current_user),
-    repo: ConversationRepository = Depends(get_conversation_repo)
-):
-    """Create a new conversation"""
-    try:
-        conversation_id = await repo.create_conversation(user_id=current_user.user_id)
-        return ConversationCreateResponse(
-            conversation_id=conversation_id,
-            created_at=datetime.now().isoformat()
-        )
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to create conversation: {str(e)}"
-        )
-
-
-@router.get("/history/{conversation_id}", response_model=ConversationHistoryResponse)
-async def get_conversation_history(
-    conversation_id: str,
-    current_user: TokenData = Depends(get_current_user),
-    repo: ConversationRepository = Depends(get_conversation_repo)
-):
-    """Get conversation history by ID"""
-    try:
-        conversation = await repo.get_conversation(conversation_id)
-        
-        if not conversation:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Conversation {conversation_id} not found"
-            )
-        
-        if conversation["user_id"] != current_user.user_id:
-            raise HTTPException(
-                status_code=status.HTTP_403_FORBIDDEN,
-                detail="Access denied - you don't own this conversation"
-            )
-        
-        messages = []
-        for msg in conversation.get('messages', []):
-            messages.append(MessageModel(
-                role=msg['role'],
-                content=msg['content'],
-                timestamp=msg['timestamp'].isoformat() if isinstance(msg['timestamp'], datetime) else msg['timestamp'],
-                metadata=msg.get('metadata')
-            ))
-        
-        return ConversationHistoryResponse(
-            conversation_id=conversation_id,
-            messages=messages,
-            message_count=len(messages)
-        )
-    
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to fetch conversation history: {str(e)}"
-        )
-
-
-@router.get("/conversations")
-async def list_user_conversations(
-    limit: int = 10,
-    skip: int = 0,
-    current_user: TokenData = Depends(get_current_user),
-    repo: ConversationRepository = Depends(get_conversation_repo)
-):
-    """List all conversations for the authenticated user"""
-    try:
-        conversations = await repo.get_user_conversations(
-            user_id=current_user.user_id,
-            limit=limit,
-            skip=skip
-        )
-        
-        return {
-            "user_id": current_user.user_id,
-            "user_email": current_user.email,
-            "conversations": [
-                {
-                    "conversation_id": conv['conversation_id'],
-                    "created_at": conv['created_at'].isoformat() if isinstance(conv['created_at'], datetime) else conv['created_at'],
-                    "updated_at": conv['updated_at'].isoformat() if isinstance(conv['updated_at'], datetime) else conv['updated_at'],
-                    "message_count": len(conv.get('messages', []))
-                }
-                for conv in conversations
-            ],
-            "total": len(conversations)
-        }
-    
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to fetch conversations: {str(e)}"
-        )
-
-
-@router.delete("/conversation/{conversation_id}")
-async def delete_conversation(
-    conversation_id: str,
-    current_user: TokenData = Depends(get_current_user),
-    repo: ConversationRepository = Depends(get_conversation_repo)
-):
-    """Delete a conversation"""
-    try:
-        conversation = await repo.get_conversation(conversation_id)
-        
-        if not conversation:
-            raise HTTPException(
-                status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Conversation {conversation_id} not found"
-            )
-        
-        if conversation["user_id"] != current_user.user_id:
-            raise HTTPException(
-                status_code=status.HTTP_403_FORBIDDEN,
-                detail="Access denied - you don't own this conversation"
-            )
-        
-        success = await repo.delete_conversation(conversation_id)
-        
-        if success:
-            return {
-                "message": "Conversation deleted successfully",
-                "conversation_id": conversation_id
-            }
-        else:
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="Failed to delete conversation"
-            )
-    
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Failed to delete conversation: {str(e)}"
-        )
-
-
-@router.get("/health")
-async def chat_health():
-    """Health check for chat service (PUBLIC)"""
-    try:
-        health = await chat_service.health_check()
-        
-        return {
-            "status": "healthy",
-            "service": "chat",
-            "components": health['components'],
-            "timestamp": datetime.now().isoformat()
-        }
-    
-    except Exception as e:
-        return {
-            "status": "unhealthy",
-            "service": "chat",
-            "error": str(e),
-            "timestamp": datetime.now().isoformat()
-        }
-# ============================================================================
-
-
-
-
-
-
-
-
-
 # """
 # Chat API Endpoints (WITH AUTHENTICATION)
 # RESTful API for the Banking RAG Chatbot
@@ -417,8 +29,16 @@ async def chat_health():
 # # ============================================================================
 # router = APIRouter()
 
-# # Initialize repository
-# conversation_repo = ConversationRepository()
+
+# # ============================================================================
+# # DEPENDENCY: Get ConversationRepository instance
+# # ============================================================================
+# def get_conversation_repo() -> ConversationRepository:
+#     """
+#     Dependency that provides ConversationRepository instance.
+#     This ensures MongoDB is connected before repository is used.
+#     """
+#     return ConversationRepository()
 
 
 # # ============================================================================
@@ -426,17 +46,7 @@ async def chat_health():
 # # ============================================================================
 
 # class ChatRequest(BaseModel):
-#     """
-#     Request model for chat endpoint.
-    
-#     NOTE: user_id is now extracted from JWT token, not from request body!
-    
-#     Example:
-#         {
-#             "query": "What is my account balance?",
-#             "conversation_id": "abc-123"
-#         }
-#     """
+#     """Request model for chat endpoint"""
 #     query: str = Field(..., description="User query text", min_length=1, max_length=1000)
 #     conversation_id: Optional[str] = Field(None, description="Optional conversation ID")
     
@@ -450,11 +60,7 @@ async def chat_health():
 
 
 # class ChatResponse(BaseModel):
-#     """
-#     Response model for chat endpoint.
-    
-#     Contains the generated response plus metadata about the RAG pipeline.
-#     """
+#     """Response model for chat endpoint"""
 #     response: str = Field(..., description="Generated response text")
 #     conversation_id: str = Field(..., description="Conversation ID")
 #     policy_action: str = Field(..., description="Policy decision: FETCH or NO_FETCH")
@@ -465,11 +71,6 @@ async def chat_health():
 #     timestamp: str = Field(..., description="Response timestamp (ISO format)")
 
 
-# class ConversationCreateRequest(BaseModel):
-#     """Request to create a new conversation (no user_id needed - from token)"""
-#     pass  # Empty - user_id comes from JWT token
-
-
 # class ConversationCreateResponse(BaseModel):
 #     """Response after creating a conversation"""
 #     conversation_id: str = Field(..., description="Created conversation ID")
@@ -498,43 +99,25 @@ async def chat_health():
 # @router.post("/", response_model=ChatResponse, status_code=status.HTTP_200_OK)
 # async def chat(
 #     request: ChatRequest,
-#     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
+#     current_user: TokenData = Depends(get_current_user),
+#     repo: ConversationRepository = Depends(get_conversation_repo)  # ← INJECT REPO
 # ):
 #     """
 #     Main chat endpoint - Send a query and get a response.
     
 #     **REQUIRES AUTHENTICATION** - JWT token must be provided in Authorization header.
-    
-#     This endpoint:
-#     1. Extracts user_id from JWT token
-#     2. Processes the query through the RAG pipeline
-#     3. Saves messages to MongoDB
-#     4. Logs retrieval data for RL training
-#     5. Returns response with metadata
-    
-#     Args:
-#         request: ChatRequest with query and optional conversation_id
-#         current_user: Authenticated user data from JWT token
-    
-#     Returns:
-#         ChatResponse: Generated response with metadata
-    
-#     Raises:
-#         HTTPException: If processing fails or user not authenticated
 #     """
 #     try:
-#         # Get user_id from token (NOT from request body!)
+#         # Get user_id from token
 #         user_id = current_user.user_id
         
 #         # If no conversation_id provided, create a new conversation
 #         conversation_id = request.conversation_id
 #         if not conversation_id:
-#             conversation_id = await conversation_repo.create_conversation(
-#                 user_id=user_id
-#             )
+#             conversation_id = await repo.create_conversation(user_id=user_id)
 #         else:
 #             # Verify user owns this conversation
-#             conversation = await conversation_repo.get_conversation(conversation_id)
+#             conversation = await repo.get_conversation(conversation_id)
 #             if not conversation:
 #                 raise HTTPException(
 #                     status_code=status.HTTP_404_NOT_FOUND,
@@ -547,13 +130,13 @@ async def chat_health():
 #                 )
         
 #         # Get conversation history
-#         history = await conversation_repo.get_conversation_history(
+#         history = await repo.get_conversation_history(
 #             conversation_id=conversation_id,
-#             max_messages=10  # Last 5 turns (10 messages)
+#             max_messages=10
 #         )
         
-#         # Save user message to database
-#         await conversation_repo.add_message(
+#         # Save user message
+#         await repo.add_message(
 #             conversation_id=conversation_id,
 #             message={
 #                 'role': 'user',
@@ -569,8 +152,8 @@ async def chat_health():
 #             user_id=user_id
 #         )
         
-#         # Save assistant message to database
-#         await conversation_repo.add_message(
+#         # Save assistant message
+#         await repo.add_message(
 #             conversation_id=conversation_id,
 #             message={
 #                 'role': 'assistant',
@@ -586,7 +169,7 @@ async def chat_health():
 #         )
         
 #         # Log retrieval data for RL training
-#         await conversation_repo.log_retrieval({
+#         await repo.log_retrieval({
 #             'conversation_id': conversation_id,
 #             'user_id': user_id,
 #             'query': request.query,
@@ -616,9 +199,11 @@ async def chat_health():
 #         )
     
 #     except HTTPException:
-#         raise  # Re-raise HTTP exceptions
+#         raise
 #     except Exception as e:
 #         print(f"❌ Chat endpoint error: {e}")
+#         import traceback
+#         traceback.print_exc()
 #         raise HTTPException(
 #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
 #             detail=f"Failed to process chat request: {str(e)}"
@@ -627,29 +212,16 @@ async def chat_health():
 
 # @router.post("/conversation", response_model=ConversationCreateResponse, status_code=status.HTTP_201_CREATED)
 # async def create_conversation(
-#     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
+#     current_user: TokenData = Depends(get_current_user),
+#     repo: ConversationRepository = Depends(get_conversation_repo)
 # ):
-#     """
-#     Create a new conversation.
-    
-#     **REQUIRES AUTHENTICATION** - User ID is extracted from JWT token.
-    
-#     Args:
-#         current_user: Authenticated user data from JWT token
-    
-#     Returns:
-#         ConversationCreateResponse: Created conversation ID
-#     """
+#     """Create a new conversation"""
 #     try:
-#         conversation_id = await conversation_repo.create_conversation(
-#             user_id=current_user.user_id
-#         )
-        
+#         conversation_id = await repo.create_conversation(user_id=current_user.user_id)
 #         return ConversationCreateResponse(
 #             conversation_id=conversation_id,
 #             created_at=datetime.now().isoformat()
 #         )
-    
 #     except Exception as e:
 #         raise HTTPException(
 #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -660,26 +232,12 @@ async def chat_health():
 # @router.get("/history/{conversation_id}", response_model=ConversationHistoryResponse)
 # async def get_conversation_history(
 #     conversation_id: str,
-#     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
+#     current_user: TokenData = Depends(get_current_user),
+#     repo: ConversationRepository = Depends(get_conversation_repo)
 # ):
-#     """
-#     Get conversation history by ID.
-    
-#     **REQUIRES AUTHENTICATION** - User can only access their own conversations.
-    
-#     Args:
-#         conversation_id: Conversation ID
-#         current_user: Authenticated user data from JWT token
-    
-#     Returns:
-#         ConversationHistoryResponse: List of messages
-        
-#     Raises:
-#         HTTPException: If conversation not found or user doesn't own it
-#     """
+#     """Get conversation history by ID"""
 #     try:
-#         # Get conversation
-#         conversation = await conversation_repo.get_conversation(conversation_id)
+#         conversation = await repo.get_conversation(conversation_id)
         
 #         if not conversation:
 #             raise HTTPException(
@@ -687,14 +245,12 @@ async def chat_health():
 #                 detail=f"Conversation {conversation_id} not found"
 #             )
         
-#         # Verify user owns this conversation
 #         if conversation["user_id"] != current_user.user_id:
 #             raise HTTPException(
 #                 status_code=status.HTTP_403_FORBIDDEN,
 #                 detail="Access denied - you don't own this conversation"
 #             )
         
-#         # Format messages
 #         messages = []
 #         for msg in conversation.get('messages', []):
 #             messages.append(MessageModel(
@@ -723,29 +279,17 @@ async def chat_health():
 # async def list_user_conversations(
 #     limit: int = 10,
 #     skip: int = 0,
-#     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
+#     current_user: TokenData = Depends(get_current_user),
+#     repo: ConversationRepository = Depends(get_conversation_repo)
 # ):
-#     """
-#     List all conversations for the authenticated user.
-    
-#     **REQUIRES AUTHENTICATION** - User ID is extracted from JWT token.
-    
-#     Args:
-#         limit: Maximum conversations to return (default: 10)
-#         skip: Number to skip for pagination (default: 0)
-#         current_user: Authenticated user data from JWT token
-    
-#     Returns:
-#         dict: List of conversations for current user
-#     """
+#     """List all conversations for the authenticated user"""
 #     try:
-#         conversations = await conversation_repo.get_user_conversations(
-#             user_id=current_user.user_id,  # From JWT token!
+#         conversations = await repo.get_user_conversations(
+#             user_id=current_user.user_id,
 #             limit=limit,
 #             skip=skip
 #         )
         
-#         # Format response
 #         return {
 #             "user_id": current_user.user_id,
 #             "user_email": current_user.email,
@@ -771,26 +315,12 @@ async def chat_health():
 # @router.delete("/conversation/{conversation_id}")
 # async def delete_conversation(
 #     conversation_id: str,
-#     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
+#     current_user: TokenData = Depends(get_current_user),
+#     repo: ConversationRepository = Depends(get_conversation_repo)
 # ):
-#     """
-#     Delete a conversation.
-    
-#     **REQUIRES AUTHENTICATION** - User can only delete their own conversations.
-    
-#     Args:
-#         conversation_id: Conversation ID to delete
-#         current_user: Authenticated user data from JWT token
-    
-#     Returns:
-#         dict: Success message
-        
-#     Raises:
-#         HTTPException: If conversation not found or user doesn't own it
-#     """
+#     """Delete a conversation"""
 #     try:
-#         # Get conversation
-#         conversation = await conversation_repo.get_conversation(conversation_id)
+#         conversation = await repo.get_conversation(conversation_id)
         
 #         if not conversation:
 #             raise HTTPException(
@@ -798,15 +328,13 @@ async def chat_health():
 #                 detail=f"Conversation {conversation_id} not found"
 #             )
         
-#         # Verify user owns this conversation
 #         if conversation["user_id"] != current_user.user_id:
 #             raise HTTPException(
 #                 status_code=status.HTTP_403_FORBIDDEN,
 #                 detail="Access denied - you don't own this conversation"
 #             )
         
-#         # Delete conversation
-#         success = await conversation_repo.delete_conversation(conversation_id)
+#         success = await repo.delete_conversation(conversation_id)
         
 #         if success:
 #             return {
@@ -830,14 +358,7 @@ async def chat_health():
 
 # @router.get("/health")
 # async def chat_health():
-#     """
-#     Health check for chat service.
-    
-#     **PUBLIC ENDPOINT** - No authentication required.
-    
-#     Returns:
-#         dict: Health status of chat service components
-#     """
+#     """Health check for chat service (PUBLIC)"""
 #     try:
 #         health = await chat_service.health_check()
         
@@ -855,68 +376,7 @@ async def chat_health():
 #             "error": str(e),
 #             "timestamp": datetime.now().isoformat()
 #         }
-
-
-# # ============================================================================
-# # USAGE DOCUMENTATION
 # # ============================================================================
-# """
-# === API USAGE EXAMPLES (WITH AUTHENTICATION) ===
-
-# ALL ENDPOINTS (except /health) NOW REQUIRE JWT TOKEN IN AUTHORIZATION HEADER!
-
-# 1. Register user:
-#    POST /api/v1/auth/register
-#    Body: {
-#        "email": "user@example.com",
-#        "password": "SecurePass123",
-#        "full_name": "John Doe"
-#    }
-#    Response: { "access_token": "eyJ...", "user": {...} }
-
-# 2. Login:
-#    POST /api/v1/auth/login
-#    Body: {
-#        "email": "user@example.com",
-#        "password": "SecurePass123"
-#    }
-#    Response: { "access_token": "eyJ...", "user": {...} }
-
-# 3. Send chat message (WITH TOKEN):
-#    POST /api/v1/chat/
-#    Headers: { "Authorization": "Bearer eyJ..." }
-#    Body: {
-#        "query": "What is my account balance?",
-#        "conversation_id": "conv_abc"  // optional
-#    }
-
-# 4. Get conversation history (WITH TOKEN):
-#    GET /api/v1/chat/history/conv_abc
-#    Headers: { "Authorization": "Bearer eyJ..." }
-
-# 5. List conversations (WITH TOKEN):
-#    GET /api/v1/chat/conversations?limit=10
-#    Headers: { "Authorization": "Bearer eyJ..." }
-
-# === TESTING WITH CURL ===
-
-# # 1. Register
-# TOKEN=$(curl -X POST "http://localhost:8000/api/v1/auth/register" \
-#   -H "Content-Type: application/json" \
-#   -d '{"email":"test@test.com","password":"test123","full_name":"Test User"}' \
-#   | jq -r '.access_token')
-
-# # 2. Send chat message with token
-# curl -X POST "http://localhost:8000/api/v1/chat/" \
-#   -H "Content-Type: application/json" \
-#   -H "Authorization: Bearer $TOKEN" \
-#   -d '{"query": "What is my balance?"}'
-# """
-# # ============================================================================
-
-
-
-
 
 
 
@@ -926,41 +386,30 @@ async def chat_health():
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-# # ======================================================================================================
-# # OLD CODE
-# # ======================================================================================================
-
 # # """
-# # Chat API Endpoints
+# # Chat API Endpoints (WITH AUTHENTICATION)
 # # RESTful API for the Banking RAG Chatbot
 
+# # NOW REQUIRES JWT TOKEN FOR ALL ENDPOINTS!
+
 # # Endpoints:
-# # - POST /chat - Send a message and get response
-# # - GET /chat/history/{conversation_id} - Get conversation history
-# # - POST /chat/conversation - Create new conversation
-# # - GET /chat/conversations - List user's conversations
-# # - GET /chat/health - Health check for chat service
+# # - POST /chat - Send a message and get response (PROTECTED)
+# # - GET /chat/history/{conversation_id} - Get conversation history (PROTECTED)
+# # - POST /chat/conversation - Create new conversation (PROTECTED)
+# # - GET /chat/conversations - List user's conversations (PROTECTED)
+# # - DELETE /chat/conversation/{conversation_id} - Delete conversation (PROTECTED)
+# # - GET /chat/health - Health check (PUBLIC)
 # # """
 
-# # from fastapi import APIRouter, HTTPException, status
+# # from fastapi import APIRouter, HTTPException, status, Depends
 # # from pydantic import BaseModel, Field
 # # from typing import List, Dict, Optional
 # # from datetime import datetime
 
 # # from app.services.chat_service import chat_service
 # # from app.db.repositories.conversation_repository import ConversationRepository
+# # from app.utils.dependencies import get_current_user  # AUTH DEPENDENCY
+# # from app.models.user import TokenData  # USER DATA FROM TOKEN
 
 
 # # # ============================================================================
@@ -980,23 +429,22 @@ async def chat_health():
 # #     """
 # #     Request model for chat endpoint.
     
+# #     NOTE: user_id is now extracted from JWT token, not from request body!
+    
 # #     Example:
 # #         {
 # #             "query": "What is my account balance?",
-# #             "conversation_id": "abc-123",
-# #             "user_id": "user_456"
+# #             "conversation_id": "abc-123"
 # #         }
 # #     """
 # #     query: str = Field(..., description="User query text", min_length=1, max_length=1000)
 # #     conversation_id: Optional[str] = Field(None, description="Optional conversation ID")
-# #     user_id: str = Field(..., description="User ID")
     
 # #     class Config:
 # #         json_schema_extra = {
 # #             "example": {
 # #                 "query": "What is my account balance?",
-# #                 "conversation_id": "conv-123",
-# #                 "user_id": "user-456"
+# #                 "conversation_id": "conv-123"
 # #             }
 # #         }
 
@@ -1018,8 +466,8 @@ async def chat_health():
 
 
 # # class ConversationCreateRequest(BaseModel):
-# #     """Request to create a new conversation"""
-# #     user_id: str = Field(..., description="User ID")
+# #     """Request to create a new conversation (no user_id needed - from token)"""
+# #     pass  # Empty - user_id comes from JWT token
 
 
 # # class ConversationCreateResponse(BaseModel):
@@ -1044,36 +492,59 @@ async def chat_health():
 
 
 # # # ============================================================================
-# # # ENDPOINTS
+# # # ENDPOINTS (ALL PROTECTED WITH JWT)
 # # # ============================================================================
 
 # # @router.post("/", response_model=ChatResponse, status_code=status.HTTP_200_OK)
-# # async def chat(request: ChatRequest):
+# # async def chat(
+# #     request: ChatRequest,
+# #     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
+# # ):
 # #     """
 # #     Main chat endpoint - Send a query and get a response.
     
+# #     **REQUIRES AUTHENTICATION** - JWT token must be provided in Authorization header.
+    
 # #     This endpoint:
-# #     1. Processes the query through the RAG pipeline
-# #     2. Saves messages to MongoDB
-# #     3. Logs retrieval data for RL training
-# #     4. Returns response with metadata
+# #     1. Extracts user_id from JWT token
+# #     2. Processes the query through the RAG pipeline
+# #     3. Saves messages to MongoDB
+# #     4. Logs retrieval data for RL training
+# #     5. Returns response with metadata
     
 # #     Args:
-# #         request: ChatRequest with query, conversation_id, user_id
+# #         request: ChatRequest with query and optional conversation_id
+# #         current_user: Authenticated user data from JWT token
     
 # #     Returns:
 # #         ChatResponse: Generated response with metadata
     
 # #     Raises:
-# #         HTTPException: If processing fails
+# #         HTTPException: If processing fails or user not authenticated
 # #     """
 # #     try:
+# #         # Get user_id from token (NOT from request body!)
+# #         user_id = current_user.user_id
+        
 # #         # If no conversation_id provided, create a new conversation
 # #         conversation_id = request.conversation_id
 # #         if not conversation_id:
 # #             conversation_id = await conversation_repo.create_conversation(
-# #                 user_id=request.user_id
+# #                 user_id=user_id
 # #             )
+# #         else:
+# #             # Verify user owns this conversation
+# #             conversation = await conversation_repo.get_conversation(conversation_id)
+# #             if not conversation:
+# #                 raise HTTPException(
+# #                     status_code=status.HTTP_404_NOT_FOUND,
+# #                     detail="Conversation not found"
+# #                 )
+# #             if conversation["user_id"] != user_id:
+# #                 raise HTTPException(
+# #                     status_code=status.HTTP_403_FORBIDDEN,
+# #                     detail="Access denied - you don't own this conversation"
+# #                 )
         
 # #         # Get conversation history
 # #         history = await conversation_repo.get_conversation_history(
@@ -1095,7 +566,7 @@ async def chat_health():
 # #         result = await chat_service.process_query(
 # #             query=request.query,
 # #             conversation_history=history,
-# #             user_id=request.user_id
+# #             user_id=user_id
 # #         )
         
 # #         # Save assistant message to database
@@ -1117,7 +588,7 @@ async def chat_health():
 # #         # Log retrieval data for RL training
 # #         await conversation_repo.log_retrieval({
 # #             'conversation_id': conversation_id,
-# #             'user_id': request.user_id,
+# #             'user_id': user_id,
 # #             'query': request.query,
 # #             'policy_action': result['policy_action'],
 # #             'policy_confidence': result['policy_confidence'],
@@ -1144,6 +615,8 @@ async def chat_health():
 # #             timestamp=result['timestamp']
 # #         )
     
+# #     except HTTPException:
+# #         raise  # Re-raise HTTP exceptions
 # #     except Exception as e:
 # #         print(f"❌ Chat endpoint error: {e}")
 # #         raise HTTPException(
@@ -1153,19 +626,23 @@ async def chat_health():
 
 
 # # @router.post("/conversation", response_model=ConversationCreateResponse, status_code=status.HTTP_201_CREATED)
-# # async def create_conversation(request: ConversationCreateRequest):
+# # async def create_conversation(
+# #     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
+# # ):
 # #     """
 # #     Create a new conversation.
     
+# #     **REQUIRES AUTHENTICATION** - User ID is extracted from JWT token.
+    
 # #     Args:
-# #         request: ConversationCreateRequest with user_id
+# #         current_user: Authenticated user data from JWT token
     
 # #     Returns:
 # #         ConversationCreateResponse: Created conversation ID
 # #     """
 # #     try:
 # #         conversation_id = await conversation_repo.create_conversation(
-# #             user_id=request.user_id
+# #             user_id=current_user.user_id
 # #         )
         
 # #         return ConversationCreateResponse(
@@ -1181,15 +658,24 @@ async def chat_health():
 
 
 # # @router.get("/history/{conversation_id}", response_model=ConversationHistoryResponse)
-# # async def get_conversation_history(conversation_id: str):
+# # async def get_conversation_history(
+# #     conversation_id: str,
+# #     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
+# # ):
 # #     """
 # #     Get conversation history by ID.
     
+# #     **REQUIRES AUTHENTICATION** - User can only access their own conversations.
+    
 # #     Args:
 # #         conversation_id: Conversation ID
+# #         current_user: Authenticated user data from JWT token
     
 # #     Returns:
 # #         ConversationHistoryResponse: List of messages
+        
+# #     Raises:
+# #         HTTPException: If conversation not found or user doesn't own it
 # #     """
 # #     try:
 # #         # Get conversation
@@ -1201,6 +687,13 @@ async def chat_health():
 # #                 detail=f"Conversation {conversation_id} not found"
 # #             )
         
+# #         # Verify user owns this conversation
+# #         if conversation["user_id"] != current_user.user_id:
+# #             raise HTTPException(
+# #                 status_code=status.HTTP_403_FORBIDDEN,
+# #                 detail="Access denied - you don't own this conversation"
+# #             )
+        
 # #         # Format messages
 # #         messages = []
 # #         for msg in conversation.get('messages', []):
@@ -1227,28 +720,35 @@ async def chat_health():
 
 
 # # @router.get("/conversations")
-# # async def list_user_conversations(user_id: str, limit: int = 10, skip: int = 0):
+# # async def list_user_conversations(
+# #     limit: int = 10,
+# #     skip: int = 0,
+# #     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
+# # ):
 # #     """
-# #     List all conversations for a user.
+# #     List all conversations for the authenticated user.
+    
+# #     **REQUIRES AUTHENTICATION** - User ID is extracted from JWT token.
     
 # #     Args:
-# #         user_id: User ID
 # #         limit: Maximum conversations to return (default: 10)
 # #         skip: Number to skip for pagination (default: 0)
+# #         current_user: Authenticated user data from JWT token
     
 # #     Returns:
-# #         dict: List of conversations
+# #         dict: List of conversations for current user
 # #     """
 # #     try:
 # #         conversations = await conversation_repo.get_user_conversations(
-# #             user_id=user_id,
+# #             user_id=current_user.user_id,  # From JWT token!
 # #             limit=limit,
 # #             skip=skip
 # #         )
         
 # #         # Format response
 # #         return {
-# #             "user_id": user_id,
+# #             "user_id": current_user.user_id,
+# #             "user_email": current_user.email,
 # #             "conversations": [
 # #                 {
 # #                     "conversation_id": conv['conversation_id'],
@@ -1268,11 +768,73 @@ async def chat_health():
 # #         )
 
 
+# # @router.delete("/conversation/{conversation_id}")
+# # async def delete_conversation(
+# #     conversation_id: str,
+# #     current_user: TokenData = Depends(get_current_user)  # ← REQUIRES AUTH!
+# # ):
+# #     """
+# #     Delete a conversation.
+    
+# #     **REQUIRES AUTHENTICATION** - User can only delete their own conversations.
+    
+# #     Args:
+# #         conversation_id: Conversation ID to delete
+# #         current_user: Authenticated user data from JWT token
+    
+# #     Returns:
+# #         dict: Success message
+        
+# #     Raises:
+# #         HTTPException: If conversation not found or user doesn't own it
+# #     """
+# #     try:
+# #         # Get conversation
+# #         conversation = await conversation_repo.get_conversation(conversation_id)
+        
+# #         if not conversation:
+# #             raise HTTPException(
+# #                 status_code=status.HTTP_404_NOT_FOUND,
+# #                 detail=f"Conversation {conversation_id} not found"
+# #             )
+        
+# #         # Verify user owns this conversation
+# #         if conversation["user_id"] != current_user.user_id:
+# #             raise HTTPException(
+# #                 status_code=status.HTTP_403_FORBIDDEN,
+# #                 detail="Access denied - you don't own this conversation"
+# #             )
+        
+# #         # Delete conversation
+# #         success = await conversation_repo.delete_conversation(conversation_id)
+        
+# #         if success:
+# #             return {
+# #                 "message": "Conversation deleted successfully",
+# #                 "conversation_id": conversation_id
+# #             }
+# #         else:
+# #             raise HTTPException(
+# #                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+# #                 detail="Failed to delete conversation"
+# #             )
+    
+# #     except HTTPException:
+# #         raise
+# #     except Exception as e:
+# #         raise HTTPException(
+# #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+# #             detail=f"Failed to delete conversation: {str(e)}"
+# #         )
+
+
 # # @router.get("/health")
 # # async def chat_health():
 # #     """
 # #     Health check for chat service.
     
+# #     **PUBLIC ENDPOINT** - No authentication required.
+    
 # #     Returns:
 # #         dict: Health status of chat service components
 # #     """
@@ -1299,48 +861,486 @@ async def chat_health():
 # # # USAGE DOCUMENTATION
 # # # ============================================================================
 # # """
-# # === API USAGE EXAMPLES ===
+# # === API USAGE EXAMPLES (WITH AUTHENTICATION) ===
 
-# # 1. Send a chat message:
-# #    POST /api/v1/chat/
+# # ALL ENDPOINTS (except /health) NOW REQUIRE JWT TOKEN IN AUTHORIZATION HEADER!
+
+# # 1. Register user:
+# #    POST /api/v1/auth/register
 # #    Body: {
-# #        "query": "What is my account balance?",
-# #        "user_id": "user_123",
-# #        "conversation_id": "conv_abc"  // optional
+# #        "email": "user@example.com",
+# #        "password": "SecurePass123",
+# #        "full_name": "John Doe"
 # #    }
+# #    Response: { "access_token": "eyJ...", "user": {...} }
 
-# # 2. Create new conversation:
-# #    POST /api/v1/chat/conversation
+# # 2. Login:
+# #    POST /api/v1/auth/login
 # #    Body: {
-# #        "user_id": "user_123"
+# #        "email": "user@example.com",
+# #        "password": "SecurePass123"
 # #    }
+# #    Response: { "access_token": "eyJ...", "user": {...} }
 
-# # 3. Get conversation history:
-# #    GET /api/v1/chat/history/conv_abc
+# # 3. Send chat message (WITH TOKEN):
+# #    POST /api/v1/chat/
+# #    Headers: { "Authorization": "Bearer eyJ..." }
+# #    Body: {
+# #        "query": "What is my account balance?",
+# #        "conversation_id": "conv_abc"  // optional
+# #    }
 
-# # 4. List user's conversations:
-# #    GET /api/v1/chat/conversations?user_id=user_123&limit=10&skip=0
+# # 4. Get conversation history (WITH TOKEN):
+# #    GET /api/v1/chat/history/conv_abc
+# #    Headers: { "Authorization": "Bearer eyJ..." }
 
-# # 5. Check health:
-# #    GET /api/v1/chat/health
+# # 5. List conversations (WITH TOKEN):
+# #    GET /api/v1/chat/conversations?limit=10
+# #    Headers: { "Authorization": "Bearer eyJ..." }
 
 # # === TESTING WITH CURL ===
 
-# # # Send chat message
+# # # 1. Register
+# # TOKEN=$(curl -X POST "http://localhost:8000/api/v1/auth/register" \
+# #   -H "Content-Type: application/json" \
+# #   -d '{"email":"test@test.com","password":"test123","full_name":"Test User"}' \
+# #   | jq -r '.access_token')
+
+# # # 2. Send chat message with token
 # # curl -X POST "http://localhost:8000/api/v1/chat/" \
 # #   -H "Content-Type: application/json" \
-# #   -d '{
-# #     "query": "What is my balance?",
-# #     "user_id": "user_123"
-# #   }'
+# #   -H "Authorization: Bearer $TOKEN" \
+# #   -d '{"query": "What is my balance?"}'
+# # """
+# # # ============================================================================
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-# # # Get history
-# # curl "http://localhost:8000/api/v1/chat/history/conv_123"
 
-# # === TESTING WITH SWAGGER UI ===
 
-# # After starting the server, visit:
-# # http://localhost:8000/docs
 
-# # Interactive API documentation with "Try it out" buttons!
-# # """
+
+
+
+
+
+# # # ======================================================================================================
+# # # OLD CODE
+# # # ======================================================================================================
+
+# # # """
+# # # Chat API Endpoints
+# # # RESTful API for the Banking RAG Chatbot
+
+# # # Endpoints:
+# # # - POST /chat - Send a message and get response
+# # # - GET /chat/history/{conversation_id} - Get conversation history
+# # # - POST /chat/conversation - Create new conversation
+# # # - GET /chat/conversations - List user's conversations
+# # # - GET /chat/health - Health check for chat service
+# # # """
+
+# # # from fastapi import APIRouter, HTTPException, status
+# # # from pydantic import BaseModel, Field
+# # # from typing import List, Dict, Optional
+# # # from datetime import datetime
+
+# # # from app.services.chat_service import chat_service
+# # # from app.db.repositories.conversation_repository import ConversationRepository
+
+
+# # # # ============================================================================
+# # # # CREATE ROUTER
+# # # # ============================================================================
+# # # router = APIRouter()
+
+# # # # Initialize repository
+# # # conversation_repo = ConversationRepository()
+
+
+# # # # ============================================================================
+# # # # PYDANTIC MODELS (Request/Response schemas)
+# # # # ============================================================================
+
+# # # class ChatRequest(BaseModel):
+# # #     """
+# # #     Request model for chat endpoint.
+    
+# # #     Example:
+# # #         {
+# # #             "query": "What is my account balance?",
+# # #             "conversation_id": "abc-123",
+# # #             "user_id": "user_456"
+# # #         }
+# # #     """
+# # #     query: str = Field(..., description="User query text", min_length=1, max_length=1000)
+# # #     conversation_id: Optional[str] = Field(None, description="Optional conversation ID")
+# # #     user_id: str = Field(..., description="User ID")
+    
+# # #     class Config:
+# # #         json_schema_extra = {
+# # #             "example": {
+# # #                 "query": "What is my account balance?",
+# # #                 "conversation_id": "conv-123",
+# # #                 "user_id": "user-456"
+# # #             }
+# # #         }
+
+
+# # # class ChatResponse(BaseModel):
+# # #     """
+# # #     Response model for chat endpoint.
+    
+# # #     Contains the generated response plus metadata about the RAG pipeline.
+# # #     """
+# # #     response: str = Field(..., description="Generated response text")
+# # #     conversation_id: str = Field(..., description="Conversation ID")
+# # #     policy_action: str = Field(..., description="Policy decision: FETCH or NO_FETCH")
+# # #     policy_confidence: float = Field(..., description="Policy confidence score (0-1)")
+# # #     documents_retrieved: int = Field(..., description="Number of documents retrieved")
+# # #     top_doc_score: Optional[float] = Field(None, description="Best document similarity score")
+# # #     total_time_ms: float = Field(..., description="Total processing time in milliseconds")
+# # #     timestamp: str = Field(..., description="Response timestamp (ISO format)")
+
+
+# # # class ConversationCreateRequest(BaseModel):
+# # #     """Request to create a new conversation"""
+# # #     user_id: str = Field(..., description="User ID")
+
+
+# # # class ConversationCreateResponse(BaseModel):
+# # #     """Response after creating a conversation"""
+# # #     conversation_id: str = Field(..., description="Created conversation ID")
+# # #     created_at: str = Field(..., description="Creation timestamp")
+
+
+# # # class MessageModel(BaseModel):
+# # #     """Single message in conversation history"""
+# # #     role: str = Field(..., description="Message role: user or assistant")
+# # #     content: str = Field(..., description="Message content")
+# # #     timestamp: str = Field(..., description="Message timestamp")
+# # #     metadata: Optional[Dict] = Field(None, description="Optional metadata")
+
+
+# # # class ConversationHistoryResponse(BaseModel):
+# # #     """Response containing conversation history"""
+# # #     conversation_id: str
+# # #     messages: List[MessageModel]
+# # #     message_count: int
+
+
+# # # # ============================================================================
+# # # # ENDPOINTS
+# # # # ============================================================================
+
+# # # @router.post("/", response_model=ChatResponse, status_code=status.HTTP_200_OK)
+# # # async def chat(request: ChatRequest):
+# # #     """
+# # #     Main chat endpoint - Send a query and get a response.
+    
+# # #     This endpoint:
+# # #     1. Processes the query through the RAG pipeline
+# # #     2. Saves messages to MongoDB
+# # #     3. Logs retrieval data for RL training
+# # #     4. Returns response with metadata
+    
+# # #     Args:
+# # #         request: ChatRequest with query, conversation_id, user_id
+    
+# # #     Returns:
+# # #         ChatResponse: Generated response with metadata
+    
+# # #     Raises:
+# # #         HTTPException: If processing fails
+# # #     """
+# # #     try:
+# # #         # If no conversation_id provided, create a new conversation
+# # #         conversation_id = request.conversation_id
+# # #         if not conversation_id:
+# # #             conversation_id = await conversation_repo.create_conversation(
+# # #                 user_id=request.user_id
+# # #             )
+        
+# # #         # Get conversation history
+# # #         history = await conversation_repo.get_conversation_history(
+# # #             conversation_id=conversation_id,
+# # #             max_messages=10  # Last 5 turns (10 messages)
+# # #         )
+        
+# # #         # Save user message to database
+# # #         await conversation_repo.add_message(
+# # #             conversation_id=conversation_id,
+# # #             message={
+# # #                 'role': 'user',
+# # #                 'content': request.query,
+# # #                 'timestamp': datetime.now()
+# # #             }
+# # #         )
+        
+# # #         # Process query through RAG pipeline
+# # #         result = await chat_service.process_query(
+# # #             query=request.query,
+# # #             conversation_history=history,
+# # #             user_id=request.user_id
+# # #         )
+        
+# # #         # Save assistant message to database
+# # #         await conversation_repo.add_message(
+# # #             conversation_id=conversation_id,
+# # #             message={
+# # #                 'role': 'assistant',
+# # #                 'content': result['response'],
+# # #                 'timestamp': datetime.now(),
+# # #                 'metadata': {
+# # #                     'policy_action': result['policy_action'],
+# # #                     'policy_confidence': result['policy_confidence'],
+# # #                     'documents_retrieved': result['documents_retrieved'],
+# # #                     'top_doc_score': result['top_doc_score']
+# # #                 }
+# # #             }
+# # #         )
+        
+# # #         # Log retrieval data for RL training
+# # #         await conversation_repo.log_retrieval({
+# # #             'conversation_id': conversation_id,
+# # #             'user_id': request.user_id,
+# # #             'query': request.query,
+# # #             'policy_action': result['policy_action'],
+# # #             'policy_confidence': result['policy_confidence'],
+# # #             'should_retrieve': result['should_retrieve'],
+# # #             'documents_retrieved': result['documents_retrieved'],
+# # #             'top_doc_score': result['top_doc_score'],
+# # #             'response': result['response'],
+# # #             'retrieval_time_ms': result['retrieval_time_ms'],
+# # #             'generation_time_ms': result['generation_time_ms'],
+# # #             'total_time_ms': result['total_time_ms'],
+# # #             'retrieved_docs_metadata': result.get('retrieved_docs_metadata', []),
+# # #             'timestamp': datetime.now()
+# # #         })
+        
+# # #         # Return response
+# # #         return ChatResponse(
+# # #             response=result['response'],
+# # #             conversation_id=conversation_id,
+# # #             policy_action=result['policy_action'],
+# # #             policy_confidence=result['policy_confidence'],
+# # #             documents_retrieved=result['documents_retrieved'],
+# # #             top_doc_score=result['top_doc_score'],
+# # #             total_time_ms=result['total_time_ms'],
+# # #             timestamp=result['timestamp']
+# # #         )
+    
+# # #     except Exception as e:
+# # #         print(f"❌ Chat endpoint error: {e}")
+# # #         raise HTTPException(
+# # #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+# # #             detail=f"Failed to process chat request: {str(e)}"
+# # #         )
+
+
+# # # @router.post("/conversation", response_model=ConversationCreateResponse, status_code=status.HTTP_201_CREATED)
+# # # async def create_conversation(request: ConversationCreateRequest):
+# # #     """
+# # #     Create a new conversation.
+    
+# # #     Args:
+# # #         request: ConversationCreateRequest with user_id
+    
+# # #     Returns:
+# # #         ConversationCreateResponse: Created conversation ID
+# # #     """
+# # #     try:
+# # #         conversation_id = await conversation_repo.create_conversation(
+# # #             user_id=request.user_id
+# # #         )
+        
+# # #         return ConversationCreateResponse(
+# # #             conversation_id=conversation_id,
+# # #             created_at=datetime.now().isoformat()
+# # #         )
+    
+# # #     except Exception as e:
+# # #         raise HTTPException(
+# # #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+# # #             detail=f"Failed to create conversation: {str(e)}"
+# # #         )
+
+
+# # # @router.get("/history/{conversation_id}", response_model=ConversationHistoryResponse)
+# # # async def get_conversation_history(conversation_id: str):
+# # #     """
+# # #     Get conversation history by ID.
+    
+# # #     Args:
+# # #         conversation_id: Conversation ID
+    
+# # #     Returns:
+# # #         ConversationHistoryResponse: List of messages
+# # #     """
+# # #     try:
+# # #         # Get conversation
+# # #         conversation = await conversation_repo.get_conversation(conversation_id)
+        
+# # #         if not conversation:
+# # #             raise HTTPException(
+# # #                 status_code=status.HTTP_404_NOT_FOUND,
+# # #                 detail=f"Conversation {conversation_id} not found"
+# # #             )
+        
+# # #         # Format messages
+# # #         messages = []
+# # #         for msg in conversation.get('messages', []):
+# # #             messages.append(MessageModel(
+# # #                 role=msg['role'],
+# # #                 content=msg['content'],
+# # #                 timestamp=msg['timestamp'].isoformat() if isinstance(msg['timestamp'], datetime) else msg['timestamp'],
+# # #                 metadata=msg.get('metadata')
+# # #             ))
+        
+# # #         return ConversationHistoryResponse(
+# # #             conversation_id=conversation_id,
+# # #             messages=messages,
+# # #             message_count=len(messages)
+# # #         )
+    
+# # #     except HTTPException:
+# # #         raise
+# # #     except Exception as e:
+# # #         raise HTTPException(
+# # #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+# # #             detail=f"Failed to fetch conversation history: {str(e)}"
+# # #         )
+
+
+# # # @router.get("/conversations")
+# # # async def list_user_conversations(user_id: str, limit: int = 10, skip: int = 0):
+# # #     """
+# # #     List all conversations for a user.
+    
+# # #     Args:
+# # #         user_id: User ID
+# # #         limit: Maximum conversations to return (default: 10)
+# # #         skip: Number to skip for pagination (default: 0)
+    
+# # #     Returns:
+# # #         dict: List of conversations
+# # #     """
+# # #     try:
+# # #         conversations = await conversation_repo.get_user_conversations(
+# # #             user_id=user_id,
+# # #             limit=limit,
+# # #             skip=skip
+# # #         )
+        
+# # #         # Format response
+# # #         return {
+# # #             "user_id": user_id,
+# # #             "conversations": [
+# # #                 {
+# # #                     "conversation_id": conv['conversation_id'],
+# # #                     "created_at": conv['created_at'].isoformat() if isinstance(conv['created_at'], datetime) else conv['created_at'],
+# # #                     "updated_at": conv['updated_at'].isoformat() if isinstance(conv['updated_at'], datetime) else conv['updated_at'],
+# # #                     "message_count": len(conv.get('messages', []))
+# # #                 }
+# # #                 for conv in conversations
+# # #             ],
+# # #             "total": len(conversations)
+# # #         }
+    
+# # #     except Exception as e:
+# # #         raise HTTPException(
+# # #             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+# # #             detail=f"Failed to fetch conversations: {str(e)}"
+# # #         )
+
+
+# # # @router.get("/health")
+# # # async def chat_health():
+# # #     """
+# # #     Health check for chat service.
+    
+# # #     Returns:
+# # #         dict: Health status of chat service components
+# # #     """
+# # #     try:
+# # #         health = await chat_service.health_check()
+        
+# # #         return {
+# # #             "status": "healthy",
+# # #             "service": "chat",
+# # #             "components": health['components'],
+# # #             "timestamp": datetime.now().isoformat()
+# # #         }
+    
+# # #     except Exception as e:
+# # #         return {
+# # #             "status": "unhealthy",
+# # #             "service": "chat",
+# # #             "error": str(e),
+# # #             "timestamp": datetime.now().isoformat()
+# # #         }
+
+
+# # # # ============================================================================
+# # # # USAGE DOCUMENTATION
+# # # # ============================================================================
+# # # """
+# # # === API USAGE EXAMPLES ===
+
+# # # 1. Send a chat message:
+# # #    POST /api/v1/chat/
+# # #    Body: {
+# # #        "query": "What is my account balance?",
+# # #        "user_id": "user_123",
+# # #        "conversation_id": "conv_abc"  // optional
+# # #    }
+
+# # # 2. Create new conversation:
+# # #    POST /api/v1/chat/conversation
+# # #    Body: {
+# # #        "user_id": "user_123"
+# # #    }
+
+# # # 3. Get conversation history:
+# # #    GET /api/v1/chat/history/conv_abc
+
+# # # 4. List user's conversations:
+# # #    GET /api/v1/chat/conversations?user_id=user_123&limit=10&skip=0
+
+# # # 5. Check health:
+# # #    GET /api/v1/chat/health
+
+# # # === TESTING WITH CURL ===
+
+# # # # Send chat message
+# # # curl -X POST "http://localhost:8000/api/v1/chat/" \
+# # #   -H "Content-Type: application/json" \
+# # #   -d '{
+# # #     "query": "What is my balance?",
+# # #     "user_id": "user_123"
+# # #   }'
+
+# # # # Get history
+# # # curl "http://localhost:8000/api/v1/chat/history/conv_123"
+
+# # # === TESTING WITH SWAGGER UI ===
+
+# # # After starting the server, visit:
+# # # http://localhost:8000/docs
+
+# # # Interactive API documentation with "Try it out" buttons!
+# # # """

app/api/v1/conversation_routes.py

@@ -0,0 +1,535 @@
+"""
+Conversation & Chat API Endpoints (UNIFIED)
+
+Combines:
+- Chat functionality (send message, get response)
+- Conversation management (list, search, rename, archive, delete)
+
+All endpoints require JWT authentication.
+"""
+
+from fastapi import APIRouter, HTTPException, status, Depends
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional
+from datetime import datetime
+
+from app.services.chat_service import chat_service
+from app.services.conversation_service import conversation_service
+from app.db.repositories.conversation_repository import conversation_repository
+from app.utils.dependencies import get_current_user
+from app.models.user import TokenData
+from app.models.conversation import (
+    CreateConversationRequest,
+    UpdateConversationRequest,
+    ConversationResponse,
+    ConversationListResult,
+    Message
+)
+
+
+# ============================================================================
+# CREATE ROUTER
+# ============================================================================
+router = APIRouter()
+
+
+# ============================================================================
+# REQUEST/RESPONSE MODELS
+# ============================================================================
+
+class ChatRequest(BaseModel):
+    """Request for chat endpoint"""
+    query: str = Field(..., min_length=1, max_length=2000)
+    conversation_id: Optional[str] = Field(None, description="Optional conversation ID. If not provided, creates new conversation.")
+    
+    class Config:
+        schema_extra = {
+            "example": {
+                "query": "What is my account balance?",
+                "conversation_id": "507f1f77bcf86cd799439011"
+            }
+        }
+
+
+class ChatResponse(BaseModel):
+    """Response from chat endpoint"""
+    response: str
+    conversation_id: str
+    policy_action: str
+    policy_confidence: float
+    documents_retrieved: int
+    top_doc_score: Optional[float]
+    total_time_ms: float
+    timestamp: str
+
+
+# ============================================================================
+# CHAT ENDPOINTS
+# ============================================================================
+
+@router.post("/", response_model=ChatResponse, status_code=status.HTTP_200_OK)
+async def chat(
+    request: ChatRequest,
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    💬 Send a message and get AI response.
+    
+    **Main chat endpoint** - processes user query through RAG pipeline.
+    
+    - If conversation_id provided: Adds to existing conversation
+    - If no conversation_id: Creates new conversation with auto-generated title
+    
+    Requires JWT authentication.
+    """
+    try:
+        user_id = current_user.user_id
+        
+        # ====================================================================
+        # STEP 1: Get or Create Conversation
+        # ====================================================================
+        conversation_id = request.conversation_id
+        
+        if conversation_id:
+            # Verify conversation exists and user owns it
+            conversation = await conversation_repository.get_conversation(conversation_id)
+            
+            if not conversation:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail="Conversation not found"
+                )
+            
+            if conversation["user_id"] != user_id:
+                raise HTTPException(
+                    status_code=status.HTTP_403_FORBIDDEN,
+                    detail="Access denied - you don't own this conversation"
+                )
+        else:
+            # Create new conversation (auto-title will be generated after first response)
+            from app.models.conversation import CreateConversationRequest
+            create_req = CreateConversationRequest(
+                title=None,  # Will be auto-generated
+                first_message=request.query
+            )
+            
+            new_conversation = await conversation_service.create_conversation(
+                user_id=user_id,
+                request=create_req,
+                llm_manager=None  # Can pass llm_manager for smart titles
+            )
+            
+            conversation_id = str(new_conversation.id)
+        
+        # ====================================================================
+        # STEP 2: Get Conversation History
+        # ====================================================================
+        history = await conversation_repository.get_conversation_history(
+            conversation_id=conversation_id,
+            max_messages=10
+        )
+        
+        # ====================================================================
+        # STEP 3: Save User Message
+        # ====================================================================
+        await conversation_repository.add_message(
+            conversation_id=conversation_id,
+            message={
+                'role': 'user',
+                'content': request.query,
+                'timestamp': datetime.utcnow(),
+                'metadata': None
+            }
+        )
+        
+        # ====================================================================
+        # STEP 4: Process Query (RAG Pipeline)
+        # ====================================================================
+        result = await chat_service.process_query(
+            query=request.query,
+            conversation_history=history,
+            user_id=user_id
+        )
+        
+        # ====================================================================
+        # STEP 5: Save Assistant Response
+        # ====================================================================
+        await conversation_repository.add_message(
+            conversation_id=conversation_id,
+            message={
+                'role': 'assistant',
+                'content': result['response'],
+                'timestamp': datetime.utcnow(),
+                'metadata': {
+                    'policy_action': result['policy_action'],
+                    'policy_confidence': result['policy_confidence'],
+                    'documents_retrieved': result['documents_retrieved'],
+                    'top_doc_score': result['top_doc_score'],
+                    'retrieval_time_ms': result['retrieval_time_ms'],
+                    'generation_time_ms': result['generation_time_ms']
+                }
+            }
+        )
+        
+        # ====================================================================
+        # STEP 6: Log Retrieval Data (for RL training)
+        # ====================================================================
+        await conversation_repository.log_retrieval({
+            'conversation_id': conversation_id,
+            'user_id': user_id,
+            'query': request.query,
+            'policy_action': result['policy_action'],
+            'policy_confidence': result['policy_confidence'],
+            'should_retrieve': result['should_retrieve'],
+            'documents_retrieved': result['documents_retrieved'],
+            'top_doc_score': result['top_doc_score'],
+            'response': result['response'],
+            'retrieval_time_ms': result['retrieval_time_ms'],
+            'generation_time_ms': result['generation_time_ms'],
+            'total_time_ms': result['total_time_ms'],
+            'retrieved_docs_metadata': result.get('retrieved_docs_metadata', []),
+            'timestamp': datetime.utcnow()
+        })
+        
+        # ====================================================================
+        # STEP 7: Return Response
+        # ====================================================================
+        return ChatResponse(
+            response=result['response'],
+            conversation_id=conversation_id,
+            policy_action=result['policy_action'],
+            policy_confidence=result['policy_confidence'],
+            documents_retrieved=result['documents_retrieved'],
+            top_doc_score=result['top_doc_score'],
+            total_time_ms=result['total_time_ms'],
+            timestamp=result['timestamp']
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        print(f"❌ Chat endpoint error: {e}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to process chat request: {str(e)}"
+        )
+
+
+# ============================================================================
+# CONVERSATION MANAGEMENT ENDPOINTS
+# ============================================================================
+
+@router.post("/conversation", response_model=ConversationResponse, status_code=status.HTTP_201_CREATED)
+async def create_conversation(
+    request: CreateConversationRequest = CreateConversationRequest(),
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    🆕 Create a new conversation.
+    
+    Optional parameters:
+    - title: Custom title (if not provided, auto-generated)
+    - first_message: Optional first message to start conversation
+    
+    Returns full conversation object.
+    """
+    try:
+        conversation = await conversation_service.create_conversation(
+            user_id=current_user.user_id,
+            request=request,
+            llm_manager=None
+        )
+        
+        return ConversationResponse(
+            id=str(conversation.id),
+            user_id=conversation.user_id,
+            title=conversation.title,
+            messages=conversation.messages,
+            is_archived=conversation.is_archived,
+            created_at=conversation.created_at,
+            updated_at=conversation.updated_at,
+            last_message_at=conversation.last_message_at,
+            message_count=conversation.message_count
+        )
+    
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to create conversation: {str(e)}"
+        )
+
+
+@router.get("/conversations", response_model=ConversationListResult)
+async def list_conversations(
+    page: int = 1,
+    page_size: int = 20,
+    include_archived: bool = False,
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    📋 List all conversations for authenticated user.
+    
+    Supports:
+    - Pagination (page, page_size)
+    - Filter archived conversations
+    - Sorted by last message (newest first)
+    
+    Returns lightweight list (without full message history).
+    """
+    try:
+        result = await conversation_service.list_conversations(
+            user_id=current_user.user_id,
+            page=page,
+            page_size=page_size,
+            include_archived=include_archived
+        )
+        
+        return result
+    
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to list conversations: {str(e)}"
+        )
+
+
+@router.get("/conversation/{conversation_id}", response_model=ConversationResponse)
+async def get_conversation(
+    conversation_id: str,
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    🔍 Get full conversation by ID.
+    
+    Returns complete conversation with all messages.
+    User must own the conversation.
+    """
+    try:
+        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"
+            )
+        
+        return ConversationResponse(
+            id=str(conversation.id),
+            user_id=conversation.user_id,
+            title=conversation.title,
+            messages=conversation.messages,
+            is_archived=conversation.is_archived,
+            created_at=conversation.created_at,
+            updated_at=conversation.updated_at,
+            last_message_at=conversation.last_message_at,
+            message_count=conversation.message_count
+        )
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get conversation: {str(e)}"
+        )
+
+
+@router.patch("/conversation/{conversation_id}", response_model=ConversationResponse)
+async def update_conversation(
+    conversation_id: str,
+    request: UpdateConversationRequest,
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    ✏️ Update conversation properties.
+    
+    Can update:
+    - title: Rename conversation
+    - is_archived: Archive/unarchive
+    
+    User must own the conversation.
+    """
+    try:
+        conversation = await conversation_service.update_conversation(
+            conversation_id=conversation_id,
+            user_id=current_user.user_id,
+            request=request
+        )
+        
+        if not conversation:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Conversation not found or access denied"
+            )
+        
+        return ConversationResponse(
+            id=str(conversation.id),
+            user_id=conversation.user_id,
+            title=conversation.title,
+            messages=conversation.messages,
+            is_archived=conversation.is_archived,
+            created_at=conversation.created_at,
+            updated_at=conversation.updated_at,
+            last_message_at=conversation.last_message_at,
+            message_count=conversation.message_count
+        )
+    
+    except HTTPException:
+        raise
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(e)
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to update conversation: {str(e)}"
+        )
+
+
+@router.delete("/conversation/{conversation_id}")
+async def delete_conversation(
+    conversation_id: str,
+    permanent: bool = False,
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    🗑️ Delete a conversation.
+    
+    - Default (permanent=False): Soft delete (can be recovered)
+    - permanent=True: Hard delete (cannot be recovered)
+    
+    User must own the conversation.
+    """
+    try:
+        success = await conversation_service.delete_conversation(
+            conversation_id=conversation_id,
+            user_id=current_user.user_id,
+            permanent=permanent
+        )
+        
+        if not success:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail="Conversation not found or access denied"
+            )
+        
+        return {
+            "message": "Conversation deleted successfully",
+            "conversation_id": conversation_id,
+            "permanent": permanent
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to delete conversation: {str(e)}"
+        )
+
+
+@router.get("/conversations/search", response_model=ConversationListResult)
+async def search_conversations(
+    query: str,
+    page: int = 1,
+    page_size: int = 20,
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    🔎 Search conversations by title or message content.
+    
+    Searches in:
+    - Conversation titles
+    - Message content
+    
+    Returns paginated results.
+    """
+    try:
+        if not query or len(query.strip()) < 2:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Search query must be at least 2 characters"
+            )
+        
+        result = await conversation_service.search_conversations(
+            user_id=current_user.user_id,
+            query=query,
+            page=page,
+            page_size=page_size
+        )
+        
+        return result
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to search conversations: {str(e)}"
+        )
+
+
+@router.get("/conversations/stats")
+async def get_conversation_stats(
+    current_user: TokenData = Depends(get_current_user)
+):
+    """
+    📊 Get conversation statistics for user.
+    
+    Returns:
+    - total: Total conversations
+    - active: Non-archived conversations
+    - archived: Archived conversations
+    """
+    try:
+        stats = await conversation_service.get_conversation_stats(
+            user_id=current_user.user_id
+        )
+        
+        return {
+            "user_id": current_user.user_id,
+            "stats": stats
+        }
+    
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get stats: {str(e)}"
+        )
+
+
+# ============================================================================
+# HEALTH CHECK
+# ============================================================================
+
+@router.get("/health")
+async def chat_health():
+    """
+    🏥 Health check for chat & conversation service.
+    
+    Public endpoint (no auth required).
+    """
+    try:
+        health = await chat_service.health_check()
+        
+        return {
+            "status": "healthy",
+            "service": "chat & conversations",
+            "components": health.get('components', {}),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    
+    except Exception as e:
+        return {
+            "status": "unhealthy",
+            "service": "chat & conversations",
+            "error": str(e),
+            "timestamp": datetime.utcnow().isoformat()
+        }

app/db/repositories/conversation_repository.py

@@ -1,9 +1,600 @@
+"""
+Conversation Repository - MongoDB Operations (UPDATED)
+
+NOW COMPATIBLE with existing chat.py!
+
+Added methods:
+- get_conversation_history() - For chat.py compatibility
+- log_retrieval() - For RL training data
+"""
+
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+from bson import ObjectId
+from pymongo import DESCENDING, ASCENDING
+
+from app.db.mongodb import get_database
+from app.models.conversation import (
+    Conversation,
+    Message,
+    ConversationListResponse,
+    ConversationListResult
+)
+
+
+# ============================================================================
+# CONVERSATION REPOSITORY
+# ============================================================================
+
+class ConversationRepository:
+    """
+    Repository for conversation operations.
+    
+    All MongoDB queries for conversations go through here.
+    """
+    
+    def __init__(self):
+        """Initialize repository with database connection"""
+        self.db = get_database()
+        self.collection_name = "conversations"
+        self.retrieval_logs_collection = "retrieval_logs"
+        print("✅ ConversationRepository initialized with MongoDB")
+    
+    @property
+    def collection(self):
+        """Get conversations collection"""
+        if self.db is None:
+            raise RuntimeError("MongoDB database not available")
+        return self.db[self.collection_name]
+    
+    @property
+    def retrieval_logs(self):
+        """Get retrieval logs collection"""
+        if self.db is None:
+            raise RuntimeError("MongoDB database not available")
+        return self.db[self.retrieval_logs_collection]
+    
+    # ========================================================================
+    # CREATE (UPDATED - Compatible with chat.py)
+    # ========================================================================
+    
+    async def create_conversation(
+        self,
+        user_id: str,
+        title: Optional[str] = None,
+        first_message: Optional[str] = None
+    ) -> str:
+        """
+        Create a new conversation.
+        
+        UPDATED: Returns conversation_id string (not full object)
+        This matches chat.py's expectation!
+        
+        Args:
+            user_id: User ID who owns the conversation
+            title: Optional conversation title
+            first_message: Optional first user message
+        
+        Returns:
+            str: conversation_id (ObjectId as string)
+        """
+        now = datetime.utcnow()
+        
+        # Auto-generate title if not provided
+        if not title:
+            if first_message:
+                # Simple title from first 50 chars
+                title = first_message[:50] + ("..." if len(first_message) > 50 else "")
+            else:
+                title = f"Conversation {now.strftime('%Y-%m-%d %H:%M')}"
+        
+        # Create conversation document
+        conversation_data = {
+            "user_id": user_id,
+            "title": title,
+            "messages": [],
+            "is_archived": False,
+            "is_deleted": False,
+            "created_at": now,
+            "updated_at": now,
+            "last_message_at": None,
+            "message_count": 0
+        }
+        
+        # Add first message if provided
+        if first_message:
+            message = {
+                "role": "user",
+                "content": first_message,
+                "timestamp": now,
+                "metadata": None
+            }
+            conversation_data["messages"].append(message)
+            conversation_data["last_message_at"] = now
+            conversation_data["message_count"] = 1
+        
+        # Insert into database
+        result = await self.collection.insert_one(conversation_data)
+        
+        # Return conversation_id as string
+        return str(result.inserted_id)
+    
+    # ========================================================================
+    # READ
+    # ========================================================================
+    
+    async def get_conversation(
+        self,
+        conversation_id: str
+    ) -> Optional[Dict]:
+        """
+        Get conversation by ID (returns raw dict).
+        
+        UPDATED: No user_id verification here (done in service layer)
+        
+        Args:
+            conversation_id: Conversation ID
+        
+        Returns:
+            dict or None: Raw conversation document
+        """
+        try:
+            result = await self.collection.find_one({
+                "_id": ObjectId(conversation_id),
+                "is_deleted": False
+            })
+            
+            if result:
+                # Add conversation_id field for compatibility
+                result['conversation_id'] = str(result['_id'])
+            
+            return result
+        
+        except Exception as e:
+            print(f"❌ Error getting conversation: {e}")
+            return None
+    
+    async def get_conversation_by_id(
+        self,
+        conversation_id: str,
+        user_id: str
+    ) -> Optional[Conversation]:
+        """
+        Get conversation by ID (with user verification, returns Pydantic model).
+        
+        Args:
+            conversation_id: Conversation ID
+            user_id: User ID (for ownership verification)
+        
+        Returns:
+            Conversation or None
+        """
+        try:
+            result = await self.collection.find_one({
+                "_id": ObjectId(conversation_id),
+                "user_id": user_id,
+                "is_deleted": False
+            })
+            
+            if result:
+                return Conversation(**result)
+            return None
+        
+        except Exception as e:
+            print(f"❌ Error getting conversation: {e}")
+            return None
+    
+    async def get_conversation_history(
+        self,
+        conversation_id: str,
+        max_messages: int = 10
+    ) -> List[Dict[str, str]]:
+        """
+        Get conversation history for chat.py compatibility.
+        
+        Returns format expected by chat_service.process_query():
+        [
+            {'role': 'user', 'content': '...', 'metadata': {...}},
+            {'role': 'assistant', 'content': '...', 'metadata': {...}}
+        ]
+        
+        Args:
+            conversation_id: Conversation ID
+            max_messages: Maximum messages to return (recent first)
+        
+        Returns:
+            List of message dicts
+        """
+        try:
+            conversation = await self.get_conversation(conversation_id)
+            
+            if not conversation:
+                return []
+            
+            messages = conversation.get('messages', [])
+            
+            # Return last N messages
+            recent_messages = messages[-max_messages:] if len(messages) > max_messages else messages
+            
+            # Convert to expected format
+            history = []
+            for msg in recent_messages:
+                history.append({
+                    'role': msg['role'],
+                    'content': msg['content'],
+                    'metadata': msg.get('metadata')
+                })
+            
+            return history
+        
+        except Exception as e:
+            print(f"❌ Error getting history: {e}")
+            return []
+    
+    async def get_user_conversations(
+        self,
+        user_id: str,
+        limit: int = 10,
+        skip: int = 0
+    ) -> List[Dict]:
+        """
+        Get conversations for a user (for chat.py compatibility).
+        
+        Args:
+            user_id: User ID
+            limit: Max conversations to return
+            skip: Number to skip (pagination)
+        
+        Returns:
+            List of conversation dicts
+        """
+        try:
+            cursor = self.collection.find({
+                "user_id": user_id,
+                "is_deleted": False
+            }).sort("updated_at", DESCENDING).skip(skip).limit(limit)
+            
+            conversations = []
+            async for doc in cursor:
+                doc['conversation_id'] = str(doc['_id'])
+                conversations.append(doc)
+            
+            return conversations
+        
+        except Exception as e:
+            print(f"❌ Error listing conversations: {e}")
+            return []
+    
+    async def list_conversations(
+        self,
+        user_id: str,
+        page: int = 1,
+        page_size: int = 20,
+        include_archived: bool = False,
+        search_query: Optional[str] = None
+    ) -> ConversationListResult:
+        """
+        List conversations with pagination and filtering (for new API).
+        
+        Args:
+            user_id: User ID
+            page: Page number (1-indexed)
+            page_size: Items per page
+            include_archived: Include archived conversations?
+            search_query: Optional search query
+        
+        Returns:
+            ConversationListResult: Paginated list
+        """
+        # Build query filter
+        query_filter = {
+            "user_id": user_id,
+            "is_deleted": False
+        }
+        
+        if not include_archived:
+            query_filter["is_archived"] = False
+        
+        if search_query:
+            query_filter["$or"] = [
+                {"title": {"$regex": search_query, "$options": "i"}},
+                {"messages.content": {"$regex": search_query, "$options": "i"}}
+            ]
+        
+        # Get total count
+        total = await self.collection.count_documents(query_filter)
+        
+        # Calculate pagination
+        skip = (page - 1) * page_size
+        has_more = (skip + page_size) < total
+        
+        # Get conversations
+        cursor = self.collection.find(query_filter).sort(
+            "last_message_at", DESCENDING
+        ).skip(skip).limit(page_size)
+        
+        conversations = []
+        async for doc in cursor:
+            preview = ""
+            if doc.get("messages"):
+                last_msg = doc["messages"][-1]
+                preview = last_msg.get("content", "")[:100]
+                if len(last_msg.get("content", "")) > 100:
+                    preview += "..."
+            
+            conversations.append(ConversationListResponse(
+                id=str(doc["_id"]),
+                user_id=doc["user_id"],
+                title=doc["title"],
+                preview=preview,
+                is_archived=doc.get("is_archived", False),
+                created_at=doc["created_at"],
+                updated_at=doc["updated_at"],
+                last_message_at=doc.get("last_message_at"),
+                message_count=doc.get("message_count", 0)
+            ))
+        
+        return ConversationListResult(
+            conversations=conversations,
+            total=total,
+            page=page,
+            page_size=page_size,
+            has_more=has_more
+        )
+    
+    # ========================================================================
+    # UPDATE
+    # ========================================================================
+    
+    async def add_message(
+        self,
+        conversation_id: str,
+        message: Dict[str, Any]
+    ) -> bool:
+        """
+        Add a message to conversation (chat.py compatible).
+        
+        Args:
+            conversation_id: Conversation ID
+            message: Message dict with role, content, timestamp, metadata
+        
+        Returns:
+            bool: True if added successfully
+        """
+        try:
+            now = datetime.utcnow()
+            
+            # Ensure timestamp is datetime
+            if 'timestamp' not in message or not isinstance(message['timestamp'], datetime):
+                message['timestamp'] = now
+            
+            result = await self.collection.update_one(
+                {
+                    "_id": ObjectId(conversation_id),
+                    "is_deleted": False
+                },
+                {
+                    "$push": {"messages": message},
+                    "$set": {
+                        "updated_at": now,
+                        "last_message_at": message['timestamp']
+                    },
+                    "$inc": {"message_count": 1}
+                }
+            )
+            
+            return result.modified_count > 0
+        
+        except Exception as e:
+            print(f"❌ Error adding message: {e}")
+            return False
+    
+    async def update_conversation(
+        self,
+        conversation_id: str,
+        user_id: str,
+        update_data: Dict[str, Any]
+    ) -> Optional[Conversation]:
+        """Update conversation properties."""
+        try:
+            update_data["updated_at"] = datetime.utcnow()
+            
+            result = await self.collection.update_one(
+                {
+                    "_id": ObjectId(conversation_id),
+                    "user_id": user_id,
+                    "is_deleted": False
+                },
+                {"$set": update_data}
+            )
+            
+            if result.modified_count > 0:
+                return await self.get_conversation_by_id(conversation_id, user_id)
+            return None
+        
+        except Exception as e:
+            print(f"❌ Error updating conversation: {e}")
+            return None
+    
+    async def rename_conversation(
+        self,
+        conversation_id: str,
+        user_id: str,
+        new_title: str
+    ) -> Optional[Conversation]:
+        """Rename a conversation."""
+        return await self.update_conversation(
+            conversation_id,
+            user_id,
+            {"title": new_title}
+        )
+    
+    async def archive_conversation(
+        self,
+        conversation_id: str,
+        user_id: str,
+        archived: bool = True
+    ) -> Optional[Conversation]:
+        """Archive or unarchive a conversation."""
+        return await self.update_conversation(
+            conversation_id,
+            user_id,
+            {"is_archived": archived}
+        )
+    
+    # ========================================================================
+    # DELETE
+    # ========================================================================
+    
+    async def delete_conversation(
+        self,
+        conversation_id: str,
+        soft_delete: bool = True
+    ) -> bool:
+        """
+        Delete a conversation (chat.py compatible - no user_id check).
+        
+        Args:
+            conversation_id: Conversation ID
+            soft_delete: If True, mark as deleted. If False, remove from DB.
+        
+        Returns:
+            bool: True if deleted
+        """
+        try:
+            if soft_delete:
+                result = await self.collection.update_one(
+                    {"_id": ObjectId(conversation_id)},
+                    {
+                        "$set": {
+                            "is_deleted": True,
+                            "updated_at": datetime.utcnow()
+                        }
+                    }
+                )
+                return result.modified_count > 0
+            else:
+                result = await self.collection.delete_one({
+                    "_id": ObjectId(conversation_id)
+                })
+                return result.deleted_count > 0
+        
+        except Exception as e:
+            print(f"❌ Error deleting conversation: {e}")
+            return False
+    
+    # ========================================================================
+    # RETRIEVAL LOGGING (For RL Training)
+    # ========================================================================
+    
+    async def log_retrieval(
+        self,
+        log_data: Dict[str, Any]
+    ) -> bool:
+        """
+        Log retrieval data for RL training.
+        
+        Stores query, policy decision, retrieval results for model improvement.
+        
+        Args:
+            log_data: Dict with retrieval metadata
+        
+        Returns:
+            bool: True if logged successfully
+        """
+        try:
+            # Ensure timestamp
+            if 'timestamp' not in log_data:
+                log_data['timestamp'] = datetime.utcnow()
+            
+            await self.retrieval_logs.insert_one(log_data)
+            return True
+        
+        except Exception as e:
+            print(f"❌ Error logging retrieval: {e}")
+            return False
+    
+    # ========================================================================
+    # SEARCH
+    # ========================================================================
+    
+    async def search_conversations(
+        self,
+        user_id: str,
+        query: str,
+        page: int = 1,
+        page_size: int = 20
+    ) -> ConversationListResult:
+        """Search conversations by title or content."""
+        return await self.list_conversations(
+            user_id=user_id,
+            page=page,
+            page_size=page_size,
+            include_archived=True,
+            search_query=query
+        )
+    
+    # ========================================================================
+    # UTILITY
+    # ========================================================================
+    
+    async def get_conversation_count(self, user_id: str) -> Dict[str, int]:
+        """Get conversation counts for a user."""
+        total = await self.collection.count_documents({
+            "user_id": user_id,
+            "is_deleted": False
+        })
+        
+        archived = await self.collection.count_documents({
+            "user_id": user_id,
+            "is_deleted": False,
+            "is_archived": True
+        })
+        
+        return {
+            "total": total,
+            "active": total - archived,
+            "archived": archived
+        }
+    
+    async def create_indexes(self):
+        """Create database indexes for better performance."""
+        try:
+            await self.collection.create_index([
+                ("user_id", ASCENDING),
+                ("is_deleted", ASCENDING),
+                ("last_message_at", DESCENDING)
+            ])
+            
+            await self.collection.create_index([
+                ("user_id", ASCENDING),
+                ("title", "text"),
+                ("messages.content", "text")
+            ])
+            
+            print("✅ Conversation indexes created")
+        
+        except Exception as e:
+            print(f"⚠️ Failed to create indexes: {e}")
+
+
+# ============================================================================
+# 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
@@ -22,16 +613,42 @@
 #     """
 #     Repository for conversation data in MongoDB.
     
-#     Collections used:
-#     - conversations: Stores complete conversations with messages
-#     - retrieval_logs: Logs each retrieval operation (for RL training)
+#     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"""
+#         """
+#         Initialize repository with database connection.
+        
+#         Gracefully handles case where MongoDB is not connected.
+#         """
 #         self.db = get_database()
-#         self.conversations = self.db["conversations"]
-#         self.retrieval_logs = self.db["retrieval_logs"]
+        
+#         # 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
@@ -51,7 +668,12 @@
         
 #         Returns:
 #             str: Conversation ID
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
 #         """
+#         self._check_connection()
+        
 #         if conversation_id is None:
 #             conversation_id = str(uuid.uuid4())
         
@@ -77,7 +699,12 @@
         
 #         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}
 #         )
@@ -88,35 +715,65 @@
         
 #         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.
-        
-#         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
-#         """
+#         """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,
@@ -138,7 +795,12 @@
         
 #         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()
@@ -168,7 +830,12 @@
         
 #         Returns:
 #             list: List of messages
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
 #         """
+#         self._check_connection()
+        
 #         conversation = await self.get_conversation(conversation_id)
         
 #         if not conversation:
@@ -190,7 +857,12 @@
         
 #         Returns:
 #             bool: Success status
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
 #         """
+#         self._check_connection()
+        
 #         result = await self.conversations.update_one(
 #             {"conversation_id": conversation_id},
 #             {
@@ -234,7 +906,12 @@
         
 #         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()
@@ -266,7 +943,12 @@
         
 #         Returns:
 #             list: List of log documents
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
 #         """
+#         self._check_connection()
+        
 #         # Build query
 #         query = {}
 #         if conversation_id:
@@ -300,7 +982,12 @@
         
 #         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},
@@ -334,7 +1021,12 @@
         
 #         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,
@@ -365,7 +1057,12 @@
         
 #         Returns:
 #             dict: Policy statistics
+        
+#         Raises:
+#             RuntimeError: If MongoDB not connected
 #         """
+#         self._check_connection()
+        
 #         # Build query
 #         query = {}
 #         if user_id:
@@ -444,606 +1141,442 @@
 
 
 
+# """
+# 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
+# # ============================================================================
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-"""
-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)
-    """
+# class ConversationRepository:
+#     """
+#     Repository for conversation data in MongoDB.
     
-    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")
+#     Collections used:
+#     - conversations: Stores complete conversations with messages
+#     - retrieval_logs: Logs each retrieval operation (for RL training)
+#     """
     
-    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."
-            )
+#     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
-    # ========================================================================
+#     # ========================================================================
+#     # 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
+#     async def create_conversation(
+#         self,
+#         user_id: str,
+#         conversation_id: Optional[str] = None
+#     ) -> str:
+#         """
+#         Create a new conversation.
         
-        Raises:
-            RuntimeError: If MongoDB not connected
-        """
-        self._check_connection()
+#         Args:
+#             user_id: User ID who owns this conversation
+#             conversation_id: Optional custom conversation ID (auto-generated if None)
         
-        if conversation_id is None:
-            conversation_id = str(uuid.uuid4())
+#         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
-        }
+#         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)
+#         await self.conversations.insert_one(conversation)
         
-        return conversation_id
+#         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
+#     async def get_conversation(self, conversation_id: str) -> Optional[Dict]:
+#         """
+#         Get a conversation by ID.
         
-        Raises:
-            RuntimeError: If MongoDB not connected
-        """
-        self._check_connection()
+#         Args:
+#             conversation_id: Conversation ID
         
-        conversation = await self.conversations.find_one(
-            {"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"])
+#         # 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
-
+#         return conversation
     
-    async def add_message(
-        self,
-        conversation_id: str,
-        message: Dict
-    ) -> bool:
-        """
-        Add a message to a 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:
-            conversation_id: Conversation ID
-            message: Message dict
-                {
-                    'role': 'user' or 'assistant',
-                    'content': str,
-                    'timestamp': datetime,
-                    'metadata': dict (optional - policy_action, docs_retrieved, etc.)
-                }
+#         Args:
+#             user_id: User ID
+#             limit: Maximum number of conversations to return
+#             skip: Number of conversations to skip (for pagination)
         
-        Returns:
-            bool: Success status
+#         Returns:
+#             list: List of conversation documents
+#         """
+#         cursor = self.conversations.find(
+#             {"user_id": user_id, "status": "active"}
+#         ).sort("updated_at", -1).skip(skip).limit(limit)
         
-        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()}
-            }
-        )
+#         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 result.modified_count > 0
+#         return conversations
     
-    async def get_conversation_history(
-        self,
-        conversation_id: str,
-        max_messages: int = None
-    ) -> List[Dict]:
-        """
-        Get conversation history (messages only).
+#     async def add_message(
+#         self,
+#         conversation_id: str,
+#         message: Dict
+#     ) -> bool:
+#         """
+#         Add a message to a conversation.
         
-        Args:
-            conversation_id: Conversation ID
-            max_messages: Optional limit on number of messages
+#         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:
-            list: List of messages
+#         Returns:
+#             bool: Success status
+#         """
+#         # Ensure timestamp exists
+#         if "timestamp" not in message:
+#             message["timestamp"] = datetime.now()
         
-        Raises:
-            RuntimeError: If MongoDB not connected
-        """
-        self._check_connection()
+#         # Add message to conversation
+#         result = await self.conversations.update_one(
+#             {"conversation_id": conversation_id},
+#             {
+#                 "$push": {"messages": message},
+#                 "$set": {"updated_at": datetime.now()}
+#             }
+#         )
         
-        conversation = await self.get_conversation(conversation_id)
+#         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).
         
-        if not conversation:
-            return []
+#         Args:
+#             conversation_id: Conversation ID
+#             max_messages: Optional limit on number of messages
         
-        messages = conversation.get("messages", [])
+#         Returns:
+#             list: List of messages
+#         """
+#         conversation = await self.get_conversation(conversation_id)
         
-        if max_messages:
-            messages = messages[-max_messages:]
+#         if not conversation:
+#             return []
         
-        return messages
-    
-    async def delete_conversation(self, conversation_id: str) -> bool:
-        """
-        Soft delete a conversation (mark as deleted, don't actually delete).
+#         messages = conversation.get("messages", [])
         
-        Args:
-            conversation_id: Conversation ID
+#         if max_messages:
+#             messages = messages[-max_messages:]
         
-        Returns:
-            bool: Success status
+#         return messages
+    
+#     async def delete_conversation(self, conversation_id: str) -> bool:
+#         """
+#         Soft delete a conversation (mark as deleted, don't actually delete).
         
-        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()
-                }
-            }
-        )
+#         Args:
+#             conversation_id: Conversation ID
         
-        return result.modified_count > 0
+#         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)
-    # ========================================================================
+#     # ========================================================================
+#     # 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
+#     async def log_retrieval(
+#         self,
+#         log_data: Dict
+#     ) -> str:
+#         """
+#         Log a retrieval operation (for RL training and analysis).
         
-        Raises:
-            RuntimeError: If MongoDB not connected
-        """
-        self._check_connection()
+#         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
+#                 }
         
-        # Add timestamp if not present
-        if "timestamp" not in log_data:
-            log_data["timestamp"] = datetime.now()
+#         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
+#         # Generate log ID
+#         log_id = str(uuid.uuid4())
+#         log_data["log_id"] = log_id
         
-        # Insert log
-        await self.retrieval_logs.insert_one(log_data)
+#         # Insert log
+#         await self.retrieval_logs.insert_one(log_data)
         
-        return log_id
+#         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
+#     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).
         
-        Raises:
-            RuntimeError: If MongoDB not connected
-        """
-        self._check_connection()
+#         Args:
+#             conversation_id: Optional filter by conversation
+#             user_id: Optional filter by user
+#             limit: Maximum number of logs
+#             skip: Number of logs to skip
         
-        # Build query
-        query = {}
-        if conversation_id:
-            query["conversation_id"] = conversation_id
-        if user_id:
-            query["user_id"] = user_id
+#         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)
+#         # 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"])
+#         # Convert ObjectIds to strings
+#         for log in logs:
+#             if "_id" in log:
+#                 log["_id"] = str(log["_id"])
         
-        return logs
+#         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
+#     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.
         
-        Raises:
-            RuntimeError: If MongoDB not connected
-        """
-        self._check_connection()
+#         Args:
+#             min_date: Optional minimum date for logs
+#             limit: Maximum number of logs
         
-        # Build query
-        query = {
-            "policy_action": {"$exists": True},
-            "response": {"$exists": True}
-        }
+#         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}
+#         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)
+#         # 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"])
+#         # Convert ObjectIds
+#         for log in logs:
+#             if "_id" in log:
+#                 log["_id"] = str(log["_id"])
         
-        return logs
+#         return logs
     
-    # ========================================================================
-    # ANALYTICS QUERIES
-    # ========================================================================
+#     # ========================================================================
+#     # 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
+#     async def get_conversation_stats(self, user_id: str) -> Dict:
+#         """
+#         Get conversation statistics for a user.
         
-        Raises:
-            RuntimeError: If MongoDB not connected
-        """
-        self._check_connection()
+#         Args:
+#             user_id: User ID
         
-        # Count total conversations
-        total_conversations = await self.conversations.count_documents({
-            "user_id": user_id,
-            "status": "active"
-        })
+#         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"}}}
-        ]
+#         # 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)
+#         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
-        }
+#         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
+#     async def get_policy_stats(self, user_id: Optional[str] = None) -> Dict:
+#         """
+#         Get policy decision statistics.
         
-        Raises:
-            RuntimeError: If MongoDB not connected
-        """
-        self._check_connection()
+#         Args:
+#             user_id: Optional user ID filter
         
-        # Build query
-        query = {}
-        if user_id:
-            query["user_id"] = user_id
+#         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"
-        })
+#         # 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"
-        })
+#         no_fetch_count = await self.retrieval_logs.count_documents({
+#             **query,
+#             "policy_action": "NO_FETCH"
+#         })
         
-        total = fetch_count + no_fetch_count
+#         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
-        }
+#         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:
+# # ============================================================================
+# # USAGE EXAMPLE (for reference)
+# # ============================================================================
+# """
+# # In your service or API endpoint:
 
-from app.db.repositories.conversation_repository import ConversationRepository
+# from app.db.repositories.conversation_repository import ConversationRepository
 
-repo = ConversationRepository()
+# repo = ConversationRepository()
 
-# Create conversation
-conv_id = await repo.create_conversation(user_id="user_123")
+# # 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 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
-    }
-})
+# # 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)
+# # 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'
-})
-"""
+# # 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/main.py

@@ -1,14 +1,11 @@
 """
-FastAPI Main Application Entry Point
+FastAPI Main Application Entry Point (UPDATED)
 
 Banking RAG Chatbot API with JWT Authentication
 
-This file:
-1. Creates the FastAPI app
-2. Configures CORS middleware
-3. Connects to MongoDB on startup/shutdown
-4. Includes API routers (auth + chat)
-5. Provides health check endpoints
+CHANGES:
+- Replaced old chat router with new conversation_routes
+- Added conversation management features
 """
 
 from fastapi import FastAPI, Request
@@ -30,6 +27,7 @@ async def lifespan(app: FastAPI):
     
     Startup:
     - Connect to MongoDB Atlas
+    - Create indexes for conversations
     - ML models load lazily on first use
     
     Shutdown:
@@ -49,6 +47,13 @@ async def lifespan(app: FastAPI):
     # Connect to MongoDB
     await connect_to_mongo()
     
+    # Create indexes for conversations (async)
+    try:
+        from app.db.repositories.conversation_repository import conversation_repository
+        await conversation_repository.create_indexes()
+    except Exception as e:
+        print(f"⚠️ Failed to create conversation indexes: {e}")
+    
     print("\n💡 ML Models Info:")
     print("   Policy Network: Loads on first chat request (lazy loading)")
     print("   Retriever Model: Loads on first retrieval (lazy loading)")
@@ -65,7 +70,6 @@ async def lifespan(app: FastAPI):
     print(f"📖 API Docs: https://eeshanyaj-questrag-backend.hf.space/docs")
     print(f"🏥 Health Check: https://eeshanyaj-questrag-backend.hf.space/health")
     print(f"🧠 Backend Link: https://eeshanyaj-questrag-backend.hf.space/")
-    # print(f"🔑 Login: POST http://localhost:8000/api/v1/auth/login")
     print("=" * 80 + "\n")
     
     yield  # Application runs here
@@ -98,16 +102,18 @@ app = FastAPI(
 - 🧠 RL-based Policy Network (BERT)
 - 🔍 Custom E5 Retriever
 - ⚡ Groq LLM with HuggingFace Fallback (Llama 3 models)
+- 📝 Conversation Management (List, Search, Archive, Delete)
 
 **Capabilities:**
 - Intelligent document retrieval
 - Context-aware responses
-- Conversation history
-- Real-time chat
+- Conversation persistence & history
+- Auto-generated conversation titles
+- Real-time chat with RAG pipeline
 - User authentication & authorization
 - Multi-provider LLM with automatic fallback
     """,
-    version="1.0.0",
+    version="2.0.0",
     docs_url="/docs",
     redoc_url="/redoc",
     lifespan=lifespan
@@ -130,10 +136,11 @@ app.add_middleware(
 )
 
 # ============================================================================
-# INCLUDE API ROUTERS
+# INCLUDE API ROUTERS (UPDATED)
 # ============================================================================
 
-from app.api.v1 import chat, auth
+from app.api.v1 import auth
+from app.api.v1 import conversation_routes  # ✅ NEW IMPORT
 
 # Auth router (public endpoints - register, login)
 app.include_router(
@@ -142,11 +149,11 @@ app.include_router(
     tags=["🔐 Authentication"]
 )
 
-# Chat router (protected endpoints - requires JWT token)
+# Conversation & Chat router (protected endpoints - requires JWT token)
 app.include_router(
-    chat.router,
+    conversation_routes.router,  # ✅ NEW ROUTER
     prefix="/api/v1/chat",
-    tags=["💬 Chat"]
+    tags=["💬 Chat & Conversations"]
 )
 
 # ============================================================================
@@ -159,8 +166,8 @@ async def root():
     Root endpoint - API information and available endpoints
     """
     return {
-        "message": "Banking RAG Chatbot API with Authentication",
-        "version": "1.0.0",
+        "message": "Banking RAG Chatbot API with Authentication & Conversation Management",
+        "version": "2.0.0",
         "status": "online",
         "authentication": "JWT Bearer Token Required for chat endpoints",
         "llm_provider": "Groq (ChatGroq) with HuggingFace fallback",
@@ -181,9 +188,13 @@ async def root():
             },
             "chat": {
                 "send_message": "POST /api/v1/chat/ (requires token)",
-                "get_history": "GET /api/v1/chat/history/{conversation_id} (requires token)",
+                "create_conversation": "POST /api/v1/chat/conversation (requires token)",
                 "list_conversations": "GET /api/v1/chat/conversations (requires token)",
-                "delete_conversation": "DELETE /api/v1/chat/conversation/{conversation_id} (requires token)"
+                "get_conversation": "GET /api/v1/chat/conversation/{id} (requires token)",
+                "update_conversation": "PATCH /api/v1/chat/conversation/{id} (requires token)",
+                "delete_conversation": "DELETE /api/v1/chat/conversation/{id} (requires token)",
+                "search_conversations": "GET /api/v1/chat/conversations/search (requires token)",
+                "conversation_stats": "GET /api/v1/chat/conversations/stats (requires token)"
             },
             "health": "GET /health"
         }
@@ -249,6 +260,7 @@ async def health_check():
     return {
         "status": "healthy" if is_healthy else "degraded",
         "api": "online",
+        "version": "2.0.0",
         "mongodb": mongodb_status,
         "authentication": auth_status,
         "llm_providers": llm_providers,
@@ -299,3 +311,306 @@ if __name__ == "__main__":
         port=8000,
         reload=settings.DEBUG  # Auto-reload only in debug mode
     )
+
+
+# """
+# FastAPI Main Application Entry Point
+
+# Banking RAG Chatbot API with JWT Authentication
+
+# This file:
+# 1. Creates the FastAPI app
+# 2. Configures CORS middleware
+# 3. Connects to MongoDB on startup/shutdown
+# 4. Includes API routers (auth + chat)
+# 5. Provides health check endpoints
+# """
+
+# from fastapi import FastAPI, Request
+# from fastapi.middleware.cors import CORSMiddleware
+# from fastapi.responses import JSONResponse
+# from contextlib import asynccontextmanager
+
+# from app.config import settings
+# from app.db.mongodb import connect_to_mongo, close_mongo_connection
+
+# # ============================================================================
+# # LIFESPAN MANAGER (Startup & Shutdown)
+# # ============================================================================
+
+# @asynccontextmanager
+# async def lifespan(app: FastAPI):
+#     """
+#     Manage application lifespan events.
+    
+#     Startup:
+#     - Connect to MongoDB Atlas
+#     - ML models load lazily on first use
+    
+#     Shutdown:
+#     - Close MongoDB connection
+#     - Cleanup resources
+#     """
+#     # ========================================================================
+#     # STARTUP
+#     # ========================================================================
+#     print("\n" + "=" * 80)
+#     print("🚀 STARTING BANKING RAG CHATBOT API")
+#     print("=" * 80)
+#     print(f"Environment: {settings.ENVIRONMENT}")
+#     print(f"Debug Mode: {settings.DEBUG}")
+#     print("=" * 80)
+    
+#     # Connect to MongoDB
+#     await connect_to_mongo()
+    
+#     print("\n💡 ML Models Info:")
+#     print("   Policy Network: Loads on first chat request (lazy loading)")
+#     print("   Retriever Model: Loads on first retrieval (lazy loading)")
+#     print("   LLM: Groq (ChatGroq) with HuggingFace fallback")
+#     print("\n🤖 LLM Configuration:")
+#     print(f"   Chat Model: {settings.GROQ_CHAT_MODEL} (Llama 3 8B)")
+#     print(f"   Eval Model: {settings.GROQ_EVAL_MODEL} (Llama 3 70B)")
+#     print(f"   Groq API Keys: {len(settings.get_groq_api_keys())} configured")
+#     print(f"   HuggingFace Tokens: {len(settings.get_hf_tokens())} configured")
+#     print(f"   Fallback: Groq → HuggingFace")
+    
+#     print("\n✅ Backend startup complete!")
+#     print("=" * 80)
+#     print(f"📖 API Docs: https://eeshanyaj-questrag-backend.hf.space/docs")
+#     print(f"🏥 Health Check: https://eeshanyaj-questrag-backend.hf.space/health")
+#     print(f"🧠 Backend Link: https://eeshanyaj-questrag-backend.hf.space/")
+#     # print(f"🔑 Login: POST http://localhost:8000/api/v1/auth/login")
+#     print("=" * 80 + "\n")
+    
+#     yield  # Application runs here
+    
+#     # ========================================================================
+#     # SHUTDOWN
+#     # ========================================================================
+#     print("\n" + "=" * 80)
+#     print("🛑 SHUTTING DOWN API")
+#     print("=" * 80)
+    
+#     # Close MongoDB connection
+#     await close_mongo_connection()
+    
+#     print("✅ Shutdown complete")
+#     print("=" * 80 + "\n")
+
+# # ============================================================================
+# # CREATE FASTAPI APPLICATION
+# # ============================================================================
+
+# app = FastAPI(
+#     title="Banking RAG Chatbot API",
+#     description="""
+# 🤖 AI-powered Banking Assistant with:
+
+# **Features:**
+# - 🔐 JWT Authentication (Sign up, Login, Protected routes)
+# - 💬 RAG (Retrieval-Augmented Generation)
+# - 🧠 RL-based Policy Network (BERT)
+# - 🔍 Custom E5 Retriever
+# - ⚡ Groq LLM with HuggingFace Fallback (Llama 3 models)
+
+# **Capabilities:**
+# - Intelligent document retrieval
+# - Context-aware responses
+# - Conversation history
+# - Real-time chat
+# - User authentication & authorization
+# - Multi-provider LLM with automatic fallback
+#     """,
+#     version="1.0.0",
+#     docs_url="/docs",
+#     redoc_url="/redoc",
+#     lifespan=lifespan
+# )
+
+# # ============================================================================
+# # CORS MIDDLEWARE
+# # ============================================================================
+
+# allowed_origins = settings.get_allowed_origins()
+# print("\n🌐 CORS Configuration:")
+# print(f"   Allowed Origins: {allowed_origins}")
+
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=allowed_origins,
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# # ============================================================================
+# # INCLUDE API ROUTERS
+# # ============================================================================
+
+# from app.api.v1 import chat, auth
+
+# # Auth router (public endpoints - register, login)
+# app.include_router(
+#     auth.router,
+#     prefix="/api/v1/auth",
+#     tags=["🔐 Authentication"]
+# )
+
+# # Chat router (protected endpoints - requires JWT token)
+# app.include_router(
+#     chat.router,
+#     prefix="/api/v1/chat",
+#     tags=["💬 Chat"]
+# )
+
+# # ============================================================================
+# # ROOT ENDPOINTS
+# # ============================================================================
+
+# @app.get("/", tags=["📍 Root"])
+# async def root():
+#     """
+#     Root endpoint - API information and available endpoints
+#     """
+#     return {
+#         "message": "Banking RAG Chatbot API with Authentication",
+#         "version": "1.0.0",
+#         "status": "online",
+#         "authentication": "JWT Bearer Token Required for chat endpoints",
+#         "llm_provider": "Groq (ChatGroq) with HuggingFace fallback",
+#         "models": {
+#             "chat": settings.GROQ_CHAT_MODEL,
+#             "evaluation": settings.GROQ_EVAL_MODEL
+#         },
+#         "documentation": {
+#             "swagger_ui": "/docs",
+#             "redoc": "/redoc"
+#         },
+#         "endpoints": {
+#             "auth": {
+#                 "register": "POST /api/v1/auth/register",
+#                 "login": "POST /api/v1/auth/login",
+#                 "me": "GET /api/v1/auth/me (requires token)",
+#                 "logout": "POST /api/v1/auth/logout (requires token)"
+#             },
+#             "chat": {
+#                 "send_message": "POST /api/v1/chat/ (requires token)",
+#                 "get_history": "GET /api/v1/chat/history/{conversation_id} (requires token)",
+#                 "list_conversations": "GET /api/v1/chat/conversations (requires token)",
+#                 "delete_conversation": "DELETE /api/v1/chat/conversation/{conversation_id} (requires token)"
+#             },
+#             "health": "GET /health"
+#         }
+#     }
+
+# @app.get("/health", tags=["🏥 Health"])
+# async def health_check():
+#     """
+#     Comprehensive health check endpoint
+    
+#     Checks status of:
+#     - API service
+#     - MongoDB connection
+#     - ML models (lazy loaded)
+#     - Authentication system
+#     - LLM providers (Groq & HuggingFace)
+    
+#     Returns:
+#         dict: Health status of all components
+#     """
+#     from app.db.mongodb import get_database
+    
+#     # Check MongoDB
+#     mongodb_status = "connected" if get_database() is not None else "disconnected"
+    
+#     # Check ML models (don't load them, just check readiness)
+#     ml_models_status = {
+#         "policy_network": "ready (lazy load)",
+#         "retriever": "ready (lazy load)",
+#         "llm": "ready (API-based)"
+#     }
+    
+#     # Check LLM providers
+#     llm_providers = {
+#         "groq": {
+#             "enabled": settings.is_groq_enabled(),
+#             "api_keys_configured": len(settings.get_groq_api_keys()),
+#             "chat_model": settings.GROQ_CHAT_MODEL,
+#             "eval_model": settings.GROQ_EVAL_MODEL
+#         },
+#         "huggingface": {
+#             "enabled": settings.is_hf_enabled(),
+#             "tokens_configured": len(settings.get_hf_tokens()),
+#             "chat_model": settings.HF_CHAT_MODEL,
+#             "eval_model": settings.HF_EVAL_MODEL
+#         }
+#     }
+    
+#     # Check authentication
+#     auth_status = {
+#         "jwt_enabled": bool(settings.SECRET_KEY and settings.SECRET_KEY != "your-secret-key-change-in-production"),
+#         "algorithm": settings.ALGORITHM,
+#         "token_expiry_minutes": settings.ACCESS_TOKEN_EXPIRE_MINUTES
+#     }
+    
+#     # Overall health
+#     is_healthy = (
+#         mongodb_status == "connected" and 
+#         auth_status["jwt_enabled"] and
+#         (llm_providers["groq"]["enabled"] or llm_providers["huggingface"]["enabled"])
+#     )
+    
+#     return {
+#         "status": "healthy" if is_healthy else "degraded",
+#         "api": "online",
+#         "mongodb": mongodb_status,
+#         "authentication": auth_status,
+#         "llm_providers": llm_providers,
+#         "ml_models": ml_models_status,
+#         "environment": settings.ENVIRONMENT,
+#         "debug_mode": settings.DEBUG
+#     }
+
+# # ============================================================================
+# # GLOBAL EXCEPTION HANDLER
+# # ============================================================================
+
+# @app.exception_handler(Exception)
+# async def global_exception_handler(request: Request, exc: Exception):
+#     """
+#     Global exception handler for unhandled errors
+#     """
+#     print(f"\n❌ Unhandled Exception:")
+#     print(f"   Path: {request.url.path}")
+#     print(f"   Error: {str(exc)}")
+    
+#     if settings.DEBUG:
+#         import traceback
+#         traceback.print_exc()
+    
+#     return JSONResponse(
+#         status_code=500,
+#         content={
+#             "error": "Internal Server Error",
+#             "detail": str(exc) if settings.DEBUG else "An unexpected error occurred",
+#             "path": str(request.url.path)
+#         }
+#     )
+
+# # ============================================================================
+# # MAIN ENTRY POINT (for direct execution)
+# # ============================================================================
+
+# if __name__ == "__main__":
+#     import uvicorn
+    
+#     print("\n🚀 Starting server directly...")
+#     print("   Note: For production, use: uvicorn app.main:app --host 0.0.0.0 --port 8000")
+    
+#     uvicorn.run(
+#         "app.main:app",
+#         host="0.0.0.0",
+#         port=8000,
+#         reload=settings.DEBUG  # Auto-reload only in debug mode
+#     )

app/models/conversation.py

@@ -0,0 +1,273 @@
+"""
+Conversation Models for MongoDB
+
+Handles conversation persistence with:
+- Auto-generated titles from first message
+- Message metadata (policy actions, retrieval stats)
+- Archive/unarchive support
+- Search indexing ready
+"""
+
+from datetime import datetime
+from typing import List, Optional, Dict, Any
+from pydantic import BaseModel, Field
+from bson import ObjectId
+
+
+# ============================================================================
+# CUSTOM TYPES
+# ============================================================================
+
+class PyObjectId(ObjectId):
+    """Custom ObjectId type for Pydantic validation"""
+    
+    @classmethod
+    def __get_validators__(cls):
+        yield cls.validate
+    
+    @classmethod
+    def validate(cls, v):
+        if not ObjectId.is_valid(v):
+            raise ValueError("Invalid ObjectId")
+        return ObjectId(v)
+    
+    @classmethod
+    def __modify_schema__(cls, field_schema):
+        field_schema.update(type="string")
+
+
+# ============================================================================
+# MESSAGE MODEL
+# ============================================================================
+
+class Message(BaseModel):
+    """
+    Single message in a conversation.
+    
+    Contains:
+    - User/assistant content
+    - Metadata from RAG pipeline (policy action, retrieval stats)
+    - 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."
+    )
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+        schema_extra = {
+            "example": {
+                "role": "user",
+                "content": "What is my account balance?",
+                "timestamp": "2024-01-15T10:30:00",
+                "metadata": None
+            }
+        }
+
+
+# ============================================================================
+# CONVERSATION MODEL (MongoDB Document)
+# ============================================================================
+
+class Conversation(BaseModel):
+    """
+    Full conversation document stored in MongoDB.
+    
+    Features:
+    - Auto-generated title from first user message
+    - Message history with metadata
+    - Archive/active status
+    - User association
+    - Search-ready structure
+    """
+    
+    id: Optional[PyObjectId] = Field(alias="_id", default=None)
+    user_id: str = Field(..., description="User ID who owns this conversation")
+    title: str = Field(..., description="Conversation title (auto-generated or custom)")
+    
+    messages: List[Message] = Field(
+        default_factory=list,
+        description="List of messages in chronological order"
+    )
+    
+    # Status flags
+    is_archived: bool = Field(default=False, description="Is conversation archived?")
+    is_deleted: bool = Field(default=False, description="Soft delete flag")
+    
+    # Timestamps
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+    last_message_at: Optional[datetime] = Field(default=None)
+    
+    # Metadata
+    message_count: int = Field(default=0, description="Total messages (excluding deleted)")
+    
+    class Config:
+        allow_population_by_field_name = True
+        arbitrary_types_allowed = True
+        json_encoders = {
+            ObjectId: str,
+            datetime: lambda v: v.isoformat()
+        }
+        schema_extra = {
+            "example": {
+                "user_id": "user_123",
+                "title": "Account Balance Inquiry",
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": "What is my account balance?",
+                        "timestamp": "2024-01-15T10:30:00"
+                    },
+                    {
+                        "role": "assistant",
+                        "content": "Your current account balance is...",
+                        "timestamp": "2024-01-15T10:30:05",
+                        "metadata": {
+                            "policy_action": "FETCH",
+                            "confidence": 0.95,
+                            "documents_retrieved": 3
+                        }
+                    }
+                ],
+                "is_archived": False,
+                "created_at": "2024-01-15T10:30:00",
+                "updated_at": "2024-01-15T10:30:05",
+                "message_count": 2
+            }
+        }
+
+
+# ============================================================================
+# REQUEST/RESPONSE MODELS (for API)
+# ============================================================================
+
+class CreateConversationRequest(BaseModel):
+    """Request body for creating a new conversation"""
+    
+    title: Optional[str] = Field(
+        default=None,
+        description="Optional custom title. If not provided, will be auto-generated from first message",
+        max_length=100
+    )
+    first_message: Optional[str] = Field(
+        default=None,
+        description="Optional first user message to start the conversation",
+        max_length=1000
+    )
+    
+    class Config:
+        schema_extra = {
+            "example": {
+                "title": "Savings Account Help",
+                "first_message": "How do I open a savings account?"
+            }
+        }
+
+
+class AddMessageRequest(BaseModel):
+    """Request body for adding a message to conversation"""
+    
+    message: str = Field(..., description="User message to add")
+    
+    class Config:
+        schema_extra = {
+            "example": {
+                "message": "What are the interest rates?"
+            }
+        }
+
+
+class UpdateConversationRequest(BaseModel):
+    """Request body for updating conversation properties"""
+    
+    title: Optional[str] = Field(default=None, description="New title")
+    is_archived: Optional[bool] = Field(default=None, description="Archive status")
+    
+    class Config:
+        schema_extra = {
+            "example": {
+                "title": "Fixed Deposit Rates Discussion"
+            }
+        }
+
+
+class ConversationResponse(BaseModel):
+    """Response model for single conversation"""
+    
+    id: str = Field(..., description="Conversation ID")
+    user_id: str
+    title: str
+    messages: List[Message]
+    is_archived: bool
+    created_at: datetime
+    updated_at: datetime
+    last_message_at: Optional[datetime]
+    message_count: int
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+
+class ConversationListResponse(BaseModel):
+    """Response model for list of conversations (without full messages)"""
+    
+    id: str
+    user_id: str
+    title: str
+    preview: str = Field(..., description="Last message preview (first 100 chars)")
+    is_archived: bool
+    created_at: datetime
+    updated_at: datetime
+    last_message_at: Optional[datetime]
+    message_count: int
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+        schema_extra = {
+            "example": {
+                "id": "507f1f77bcf86cd799439011",
+                "user_id": "user_123",
+                "title": "Account Balance Inquiry",
+                "preview": "What is my current account balance?",
+                "is_archived": False,
+                "created_at": "2024-01-15T10:30:00",
+                "updated_at": "2024-01-15T10:35:00",
+                "last_message_at": "2024-01-15T10:35:00",
+                "message_count": 6
+            }
+        }
+
+
+class ConversationListResult(BaseModel):
+    """Paginated list of conversations"""
+    
+    conversations: List[ConversationListResponse]
+    total: int = Field(..., description="Total conversations matching filter")
+    page: int = Field(default=1, description="Current page number")
+    page_size: int = Field(default=20, description="Items per page")
+    has_more: bool = Field(..., description="Are there more pages?")
+    
+    class Config:
+        schema_extra = {
+            "example": {
+                "conversations": [],
+                "total": 42,
+                "page": 1,
+                "page_size": 20,
+                "has_more": True
+            }
+        }

app/services/conversation_service.py

@@ -0,0 +1,503 @@
+"""
+Conversation Service - Business Logic Layer (UPDATED)
+
+OPTIMIZED:
+- Better error handling
+- Smart title generation with fallbacks
+- Async LLM title generation (optional)
+- User verification in all operations
+"""
+
+import re
+from typing import Optional, Dict, Any
+from datetime import datetime
+
+from app.db.repositories.conversation_repository import conversation_repository
+from app.models.conversation import (
+    Conversation,
+    Message,
+    ConversationListResult,
+    CreateConversationRequest,
+    UpdateConversationRequest
+)
+
+
+# ============================================================================
+# CONVERSATION SERVICE
+# ============================================================================
+
+class ConversationService:
+    """
+    Business logic for conversation management.
+    
+    Handles validation, auto-titles, and business rules.
+    """
+    
+    def __init__(self):
+        """Initialize service"""
+        self.repository = conversation_repository
+        print("✅ ConversationService initialized")
+    
+    # ========================================================================
+    # AUTO-TITLE GENERATION
+    # ========================================================================
+    
+    def generate_title_from_message(
+        self,
+        message: str,
+        max_length: int = 50
+    ) -> str:
+        """
+        Generate conversation title from first user message.
+        
+        Optimized with better truncation logic.
+        
+        Args:
+            message: First user message
+            max_length: Maximum title length
+        
+        Returns:
+            str: Generated title
+        """
+        message = message.strip()
+        
+        if not message:
+            return "New Conversation"
+        
+        # Remove extra whitespace
+        message = re.sub(r'\s+', ' ', message)
+        
+        # Try first sentence
+        sentences = re.split(r'[.!?]+', message)
+        first_sentence = sentences[0].strip()
+        
+        # Use more if first sentence too short
+        if len(first_sentence) < 15 and len(sentences) > 1:
+            first_sentence = f"{first_sentence}. {sentences[1].strip()}"
+        
+        # Truncate smartly
+        if len(first_sentence) > max_length:
+            title = first_sentence[:max_length].strip()
+            # Break at word boundary
+            last_space = title.rfind(' ')
+            if last_space > max_length * 0.6:
+                title = title[:last_space]
+            title += "..."
+        else:
+            title = first_sentence
+        
+        # Capitalize
+        if title:
+            title = title[0].upper() + title[1:]
+        
+        # Remove trailing punctuation before ellipsis
+        title = re.sub(r'[,;:]\.\.\.$', '...', title)
+        
+        return title if title else "New Conversation"
+    
+    async def generate_smart_title(
+        self,
+        first_message: str,
+        llm_manager = None
+    ) -> str:
+        """
+        Generate smart title using LLM (optional).
+        
+        Falls back gracefully if LLM unavailable.
+        
+        Args:
+            first_message: First user message
+            llm_manager: Optional LLM manager
+        
+        Returns:
+            str: Generated title
+        """
+        # Try LLM generation if available
+        if llm_manager:
+            try:
+                prompt = f"""Generate a concise title (max 50 chars) for this banking query:
+
+"{first_message}"
+
+Requirements:
+- Clear and descriptive
+- Banking/finance focused
+- No quotes or formatting
+- Maximum 50 characters
+
+Title:"""
+                
+                # Use simple generation (not full chat)
+                title = await llm_manager.generate_simple_response(
+                    prompt=prompt,
+                    max_tokens=15,
+                    temperature=0.3
+                )
+                
+                # Clean and validate
+                title = title.strip().strip('"\'`')
+                title = re.sub(r'\s+', ' ', title)
+                
+                if 5 < len(title) <= 60:
+                    return title
+            
+            except Exception as e:
+                print(f"⚠️ Smart title generation failed: {e}")
+        
+        # Fallback to simple generation
+        return self.generate_title_from_message(first_message)
+    
+    # ========================================================================
+    # CREATE
+    # ========================================================================
+    
+    async def create_conversation(
+        self,
+        user_id: str,
+        request: CreateConversationRequest = None,
+        llm_manager = None
+    ) -> Conversation:
+        """
+        Create a new conversation with optional first message.
+        
+        OPTIMIZED: Better title generation + error handling
+        
+        Args:
+            user_id: User ID
+            request: Optional create request
+            llm_manager: Optional LLM manager
+        
+        Returns:
+            Conversation: Created conversation (full object)
+        """
+        if request is None:
+            request = CreateConversationRequest()
+        
+        # Determine title
+        if request.title:
+            title = request.title
+        elif request.first_message:
+            # Auto-generate from message
+            title = await self.generate_smart_title(
+                request.first_message,
+                llm_manager
+            )
+        else:
+            title = f"New Chat - {datetime.now().strftime('%b %d, %H:%M')}"
+        
+        # Create conversation (returns ID string)
+        conversation_id = await self.repository.create_conversation(
+            user_id=user_id,
+            title=title,
+            first_message=request.first_message
+        )
+        
+        # Fetch full conversation
+        conversation = await self.repository.get_conversation_by_id(
+            conversation_id,
+            user_id
+        )
+        
+        if not conversation:
+            raise ValueError("Failed to create conversation")
+        
+        return conversation
+    
+    # ========================================================================
+    # READ
+    # ========================================================================
+    
+    async def get_conversation(
+        self,
+        conversation_id: str,
+        user_id: str
+    ) -> Optional[Conversation]:
+        """
+        Get conversation with user verification.
+        
+        Args:
+            conversation_id: Conversation ID
+            user_id: User ID (must match owner)
+        
+        Returns:
+            Conversation or None
+        """
+        return await self.repository.get_conversation_by_id(
+            conversation_id,
+            user_id
+        )
+    
+    async def list_conversations(
+        self,
+        user_id: str,
+        page: int = 1,
+        page_size: int = 20,
+        include_archived: bool = False
+    ) -> ConversationListResult:
+        """
+        List conversations for user with pagination.
+        
+        Args:
+            user_id: User ID
+            page: Page number (1-indexed)
+            page_size: Items per page
+            include_archived: Include archived?
+        
+        Returns:
+            ConversationListResult: Paginated list
+        """
+        # Validate pagination
+        page = max(1, page)
+        page_size = min(max(1, page_size), 100)  # Cap at 100
+        
+        return await self.repository.list_conversations(
+            user_id=user_id,
+            page=page,
+            page_size=page_size,
+            include_archived=include_archived
+        )
+    
+    async def search_conversations(
+        self,
+        user_id: str,
+        query: str,
+        page: int = 1,
+        page_size: int = 20
+    ) -> ConversationListResult:
+        """
+        Search conversations by title/content.
+        
+        Args:
+            user_id: User ID
+            query: Search query
+            page: Page number
+            page_size: Items per page
+        
+        Returns:
+            ConversationListResult: Search results
+        """
+        # Validate query
+        if not query or len(query.strip()) < 2:
+            # Return empty results for invalid query
+            return ConversationListResult(
+                conversations=[],
+                total=0,
+                page=page,
+                page_size=page_size,
+                has_more=False
+            )
+        
+        return await self.repository.search_conversations(
+            user_id=user_id,
+            query=query.strip(),
+            page=page,
+            page_size=page_size
+        )
+    
+    # ========================================================================
+    # UPDATE
+    # ========================================================================
+    
+    async def add_message_to_conversation(
+        self,
+        conversation_id: str,
+        user_id: str,
+        role: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None
+    ) -> Optional[Conversation]:
+        """
+        Add message to conversation with validation.
+        
+        Args:
+            conversation_id: Conversation ID
+            user_id: User ID (must match owner)
+            role: 'user' or 'assistant'
+            content: Message content
+            metadata: Optional metadata
+        
+        Returns:
+            Updated Conversation or None
+        """
+        # Validate role
+        if role not in ['user', 'assistant']:
+            raise ValueError(f"Invalid role: {role}")
+        
+        # Validate content
+        if not content or not content.strip():
+            raise ValueError("Message content cannot be empty")
+        
+        # Verify ownership
+        conversation = await self.get_conversation(conversation_id, user_id)
+        if not conversation:
+            return None
+        
+        # Create message
+        message = Message(
+            role=role,
+            content=content.strip(),
+            timestamp=datetime.utcnow(),
+            metadata=metadata
+        )
+        
+        # Add to repository
+        success = await self.repository.add_message(
+            conversation_id,
+            message.dict()
+        )
+        
+        if success:
+            return await self.get_conversation(conversation_id, user_id)
+        return None
+    
+    async def update_conversation(
+        self,
+        conversation_id: str,
+        user_id: str,
+        request: UpdateConversationRequest
+    ) -> Optional[Conversation]:
+        """
+        Update conversation properties.
+        
+        Args:
+            conversation_id: Conversation ID
+            user_id: User ID (must match owner)
+            request: Update request
+        
+        Returns:
+            Updated Conversation or None
+        """
+        update_data = {}
+        
+        if request.title is not None:
+            # Validate title
+            title = request.title.strip()
+            if not title:
+                raise ValueError("Title cannot be empty")
+            if len(title) > 100:
+                raise ValueError("Title too long (max 100 chars)")
+            update_data["title"] = title
+        
+        if request.is_archived is not None:
+            update_data["is_archived"] = request.is_archived
+        
+        if not update_data:
+            # Nothing to update
+            return await self.get_conversation(conversation_id, user_id)
+        
+        return await self.repository.update_conversation(
+            conversation_id,
+            user_id,
+            update_data
+        )
+    
+    async def rename_conversation(
+        self,
+        conversation_id: str,
+        user_id: str,
+        new_title: str
+    ) -> Optional[Conversation]:
+        """
+        Rename conversation with validation.
+        
+        Args:
+            conversation_id: Conversation ID
+            user_id: User ID
+            new_title: New title
+        
+        Returns:
+            Updated Conversation or None
+        """
+        # Validate title
+        new_title = new_title.strip()
+        if not new_title:
+            raise ValueError("Title cannot be empty")
+        if len(new_title) > 100:
+            raise ValueError("Title too long (max 100 chars)")
+        
+        return await self.repository.rename_conversation(
+            conversation_id,
+            user_id,
+            new_title
+        )
+    
+    async def archive_conversation(
+        self,
+        conversation_id: str,
+        user_id: str
+    ) -> Optional[Conversation]:
+        """Archive a conversation."""
+        return await self.repository.archive_conversation(
+            conversation_id,
+            user_id,
+            archived=True
+        )
+    
+    async def unarchive_conversation(
+        self,
+        conversation_id: str,
+        user_id: str
+    ) -> Optional[Conversation]:
+        """Unarchive a conversation."""
+        return await self.repository.archive_conversation(
+            conversation_id,
+            user_id,
+            archived=False
+        )
+    
+    # ========================================================================
+    # DELETE
+    # ========================================================================
+    
+    async def delete_conversation(
+        self,
+        conversation_id: str,
+        user_id: str,
+        permanent: bool = False
+    ) -> bool:
+        """
+        Delete conversation (with ownership verification).
+        
+        Args:
+            conversation_id: Conversation ID
+            user_id: User ID (must match owner)
+            permanent: Hard delete if True
+        
+        Returns:
+            bool: True if deleted
+        """
+        # Verify ownership first
+        conversation = await self.get_conversation(conversation_id, user_id)
+        if not conversation:
+            return False
+        
+        return await self.repository.delete_conversation(
+            conversation_id,
+            soft_delete=not permanent
+        )
+    
+    # ========================================================================
+    # UTILITY
+    # ========================================================================
+    
+    async def get_conversation_stats(
+        self,
+        user_id: str
+    ) -> Dict[str, int]:
+        """
+        Get conversation statistics.
+        
+        Args:
+            user_id: User ID
+        
+        Returns:
+            dict: Stats with total, active, archived
+        """
+        return await self.repository.get_conversation_count(user_id)
+
+
+# ============================================================================
+# GLOBAL SERVICE INSTANCE
+# ============================================================================
+
+conversation_service = ConversationService()