modified docs strings

src/backend/api_routes/chat_api.py

@@ -1,6 +1,7 @@
-from fastapi import APIRouter, HTTPException, Depends
-from fastapi.responses import JSONResponse
-from services import llm_model_service, pinecone_service, embedding_service
+from fastapi import APIRouter, HTTPException, status, Depends
+from services.embedding_service import get_text_embedding
+from services.pinecone_service import retrieve_context_from_pinecone
+from services.llm_model_service import get_health_advice
 from services.schemas import ConversationInput
 from utils import logger
 
@@ -8,15 +9,38 @@ logger = logger.get_logger()
 
 router = APIRouter(prefix="/chat", tags=["Chat"])
 
-@router.post("/get-health-advice", response_model=dict)
-async def get_health_advice(input_data: ConversationInput):
+@router.post("/get-health-advice", response_model=dict, status_code=status.HTTP_200_OK)
+async def get_health_advice_endpoint(input_data: ConversationInput):
     """
-    Handles requests from the frontend and fetches advice using the `get_health_advice()` function.
+    Provides personalized health advice based on the user's conversation history.
 
-    Args:
-    - input_data (ConversationInput): User's conversation history.
+    ### Overview
+    This endpoint is designed to generate meaningful health advice by leveraging 
+    both the user's most recent query and the conversation history. It ensures 
+    the LLM model is aware of past interactions to maintain context and provide 
+    relevant recommendations.
 
-    Example Input:
+    ### Process Flow
+    1. **Extract User Query:**  
+       - Retrieves the most recent entry from the provided conversation history.  
+       - Ensures the entry is valid and contains a user's question.  
+
+    2. **Generate Query Embedding:**  
+       - Uses the `get_text_embedding` service to generate vector embeddings for the extracted query.  
+
+    3. **Retrieve Contextual Information:**  
+       - Uses the `retrieve_context_from_pinecone` service to fetch relevant context 
+         based on the generated embeddings.  
+
+    4. **Generate Assistant Reply:**  
+       - Passes the extracted query, retrieved context, and full conversation history to the LLM model.  
+       - The LLM utilizes this information to provide a context-aware and personalized response.  
+
+    ### Request Body
+    - **conversation_history** (List[dict]): List of chat entries representing the conversation flow.
+
+    **Example Request:**
+    ```json
     {
         "conversation_history": [
             {"role": "user", "content": "I've been feeling tired lately. What should I do?"},
@@ -24,50 +48,56 @@ async def get_health_advice(input_data: ConversationInput):
             {"role": "user", "content": "No, I just feel drained even after sleeping well."}
         ]
     }
+    ```
 
-    Returns:
-    - dict: Contains 'reply' with the assistant's response.
+    ### Response
+    - **reply** (str): The assistant's response containing tailored health advice.
 
-    Raises:
-    - HTTPException (400): If conversation history or user query is missing.
-    - HTTPException (500): If an internal error occurs during response generation.
+    **Example Response:**
+    ```json
+    {
+        "reply": "You might consider checking your vitamin levels and maintaining a consistent sleep schedule."
+    }
+    ```
+
+    ### Error Handling
+    - **400 Bad Request:** Raised if the conversation history is empty or the latest user query is missing/invalid.  
+    - **500 Internal Server Error:** Raised if an unexpected error occurs while generating the response.  
+
+    ### Notes
+    - Ensure that the conversation history follows a proper role-based structure (`role: "user"` and `role: "assistant"`).  
+    - The LLM's response quality heavily depends on the completeness and relevance of the conversation history.  
+    - The embedding and context retrieval services are essential to enhance the accuracy of the generated advice.  
     """
+
     if not input_data.conversation_history:
         logger.warning("Empty conversation history received.")
-        raise HTTPException(status_code=400, detail="Conversation history cannot be empty.")
-
-    try:
-        last_entry = input_data.conversation_history[-1]
-        if not isinstance(last_entry, dict) or last_entry.get("role") != "user":
-            logger.warning("Invalid conversation entry format or missing user query.")
-            raise HTTPException(status_code=400, detail="Invalid conversation entry or missing user query.")
-
-        user_query = last_entry.get("content")
-        if not user_query:
-            logger.warning("User query content is missing in the conversation history.")
-            raise HTTPException(status_code=400, detail="User query content cannot be empty.")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Conversation history cannot be empty."
+        )
 
-        logger.info(f"Received user query: {user_query}")
-        query_embeddings = embedding_service.get_text_embedding(user_query)
+    last_entry = input_data.conversation_history[-1]
+    user_query = last_entry.get("content")
 
-        db_response = pinecone_service.retrieve_context_from_pinecone(query_embeddings)
-        logger.info("Fetched DB response successfully.")
+    if last_entry.get("role") != "user" or not user_query:
+        logger.warning("Invalid or missing user query in conversation history.")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Invalid or missing user query."
+        )
 
-        assistant_reply = llm_model_service.get_health_advice(
+    try:
+        query_embeddings = get_text_embedding(user_query)
+        db_response = retrieve_context_from_pinecone(query_embeddings)
+        assistant_reply = get_health_advice(
             user_query, db_response, input_data.conversation_history
         )
-
-        if not assistant_reply:
-            logger.warning("Assistant generated an empty response.")
-            raise HTTPException(status_code=500, detail="Assistant generated an empty response.")
-
-        logger.info("Health advice generated successfully.")
-        return JSONResponse(content={"reply": assistant_reply}, status_code=200)
-
-    except HTTPException as http_exc:
-        logger.error(f"HTTPException occurred: {http_exc.detail}")
-        raise http_exc
+        return {"reply": assistant_reply}
 
     except Exception as e:
         logger.error(f"Unexpected error: {e}", exc_info=True)
-        raise HTTPException(status_code=500, detail="Error generating response. Please try again later.")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Error generating response. Please try again later."
+        )

src/backend/api_routes/chat_history_db_api.py

@@ -1,34 +0,0 @@
-from fastapi import APIRouter,HTTPException,status,Query
-from services.schemas import ChatHistoryRequest
-from services import supabase_service
-from utils import logger
-
-logger = logger.get_logger()
-
-router = APIRouter(prefix='/chat-db',tags=["Chat History Database API's"])
-
-@router.post('/store-history')
-def store_chat_history(chat_history : ChatHistoryRequest):
-    try:
-        conversation_id = chat_history.conversation_id
-        messages = chat_history.messages
-        return supabase_service.store_chat_history(conversation_id, messages)
-    except Exception as e:
-        raise f"Failed to create {e}"
-    
-@router.get('/get-history')
-def get_chat_history(conversation_id: str):
-    """Retrieves chat history from Supabase for a given conversation ID."""
-    try:
-        chat_history = supabase_service.get_chat_history(conversation_id)
-        return chat_history
-    except Exception as e:
-        logger.error(f"Error retrieving chat history for ID {conversation_id}: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to retrieve chat history. Please try again later."
-        )
-
-    
-
-

src/backend/api_routes/chat_history_supabase_api.py

@@ -0,0 +1,101 @@
+from typing import Dict, Any, Union
+from fastapi import APIRouter, HTTPException, status, Query
+from services.schemas import ChatHistoryRequest
+from services import supabase_service
+from utils import logger
+
+logger = logger.get_logger()
+
+router = APIRouter(
+    prefix='/chat-history',
+    tags=["Chat History Management"]
+)
+
+@router.post('/store', response_model=Dict[str, Any], status_code=status.HTTP_201_CREATED)
+def add_chat_history(chat_history: ChatHistoryRequest) -> Dict[str, Any]:
+    """
+    Save chat conversation history in the database.
+
+    **Request Body:**
+    - `conversation_id` (str): Unique identifier for the chat session.
+    - `messages` (List[Dict[str, str]]): List of messages exchanged during the session.
+
+    **Responses:**
+    - **201 Created**: Successfully stored the chat history.
+    - **400 Bad Request**: Input data validation error.
+    - **500 Internal Server Error**: Unexpected error during the saving process.
+    """
+    try:
+        response = supabase_service.store_chat_history(
+            chat_history.conversation_id,
+            chat_history.messages
+        )
+        if not response['success']:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=response.get("error", "Failed to store chat history.")
+            )
+        return response
+    except ValueError as error:
+        logger.error(f"Validation error while storing chat history: {error}")
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(error)
+        )
+    except Exception as error:
+        logger.error(f"Unexpected error while storing chat history: {error}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Unexpected error occurred. Please try again later."
+        )
+
+@router.get('/retrieve', response_model=Union[Dict[str, Any], None])
+def get_chat_history(
+    conversation_id: str = Query(..., description="Conversation ID for chat history retrieval")
+) -> Union[Dict[str, Any], None]:
+    """
+    Retrieve stored chat conversation history using a conversation ID.
+
+    **Query Parameter:**
+    - `conversation_id` (str): Unique identifier for the chat session.
+
+    **Responses:**
+    - **200 OK**: Successfully retrieved the chat history.
+    - **404 Not Found**: No chat history found for the provided conversation ID.
+    - **500 Internal Server Error**: Unexpected error occurred during retrieval.
+    """
+    try:
+        chat_history = supabase_service.retrieve_chat_history(conversation_id)
+        logger.info(f"Retrieved history: {chat_history}")
+
+        if not chat_history.get('success'):
+            error_message = chat_history.get('error', "Unknown error occurred.")
+            logger.warning(f"[404] Chat history not found for ID: {conversation_id} - {error_message}")
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"Chat history not found for ID: {conversation_id}"
+            )
+
+        logger.info(f"Chat history retrieved successfully for ID: {conversation_id}")
+        return chat_history
+
+    except KeyError as key_error:
+        logger.error(f"[500] Missing key in response data for ID {conversation_id}: {key_error}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Internal data structure error. Please contact support."
+        )
+
+    except ConnectionError:
+        logger.error(f"[500] Database connection error while retrieving ID {conversation_id}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to connect to the database. Please try again later."
+        )
+
+    except Exception as error:
+        logger.error(f"[500] Unexpected error while retrieving chat history for ID {conversation_id}: {error}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Unexpected error occurred while retrieving chat history. Please try again later."
+        )

src/backend/api_routes/knowledge_base_api.py

@@ -1,58 +1,127 @@
-from fastapi import APIRouter,HTTPException
-from services import pinecone_service,embedding_service
-from services.schemas import UpsertRequest,DeleteRequest,MetadataRequest
+from fastapi import APIRouter, HTTPException
+from services import pinecone_service, embedding_service
+from services.schemas import UpsertRequest, DeleteRequest, MetadataRequest
 import pandas as pd
 from utils import logger
+from fastapi.responses import JSONResponse
 
 logger = logger.get_logger()
 
 router = APIRouter(prefix="/knowledge-base", tags=['Knowledge Base Operations'])
 
-@router.post("/upsert-data")
+@router.post("/upsert-data", response_model=dict, status_code=200)
 def upsert_data(request: UpsertRequest):
 
     """
-    Example Input : 
-    {
-    "data": [{"input": "What is mental health?", "output": "Mental health refers to...", "instruction": "Focus on general well-being."}]
-    }
+        Upserts data into the knowledge base.
 
+        ### Example Input:
+        ```json
+        {
+            "data": [
+                {
+                    "input": "What is mental health?",
+                    "output": "Mental health refers to...",
+                    "instruction": "Focus on general well-being."
+                }
+            ]
+        }
+        ```
+
+        ### Response:
+        - **200:** Data upserted successfully.
+        - **500:** Internal server error.
     """
     try:
+        if not request.data:
+            raise HTTPException(status_code=400, detail="Data cannot be empty.")
         df = pd.DataFrame(request.data)
+        if df.empty:
+            raise HTTPException(status_code=400, detail="No valid data provided for upsert.")
         pinecone_service.upsert_vector_data(df)
-        return {"message": "Data upserted successfully."}
+        return JSONResponse(content={"message": "Data upserted successfully."}, status_code=200)
+    except (ValueError, KeyError) as e:
+        logger.error(f"Invalid data format: {e}")
+        raise HTTPException(status_code=400, detail=f"Invalid data format: {e}")
+    
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to upsert data: {e}")
+        logger.error(f"Unexpected error during data upsert: {e}")
+        raise HTTPException(status_code=500, detail="Failed to upsert data due to an unexpected error.")
     
-@router.post("/delete-records")
+@router.post("/delete-records", response_model=dict, status_code=200)
 def delete_records(request: DeleteRequest):
     """
-    Example Input : 
+    Deletes records from the knowledge base.
+
+    ### Example Input:
+    ```json
     {"ids_to_delete": ["id_123", "id_456"]}
+    ```
 
+    ### Response:
+    - **200:** Records deleted successfully.
+    - **400:** No valid IDs provided.
+    - **500:** Internal server error.
     """
     try:
+        if not request.ids_to_delete:
+            raise HTTPException(status_code=400, detail="IDs to delete cannot be empty.")
+        
         pinecone_service.delete_records_by_ids(request.ids_to_delete)
-        return {"message": "Records deleted successfully."}
+        logger.info(f"Successfully deleted records: {request.ids_to_delete}")
+        return JSONResponse(content={"message": "Records deleted successfully."}, status_code=200)
+    
+    except (ValueError, KeyError) as e:
+        logger.error(f"Invalid data format for deletion: {e}")
+        raise HTTPException(status_code=400, detail=f"Invalid data format: {e}")
+    
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to delete records: {e}")
+        logger.error(f"Unexpected error while deleting records: {e}")
+        raise HTTPException(status_code=500, detail="Failed to delete records due to an unexpected error.")
 
-@router.post("/fetch-metadata")
+@router.post("/fetch-metadata", response_model=dict, status_code=200)
 def fetch_metadata(request: MetadataRequest):
 
     """
-    Example Input :
-        {"prompt": "Tell me about mental health",
+    Retrieves relevant metadata for a given prompt.
+
+    ### Example Input:
+    ```json
+    {
+        "prompt": "Tell me about mental health",
         "n_result": 3,
-        "score_threshold": 0.47}
+        "score_threshold": 0.47
+    }
+    ```
+
+    ### Response:
+    - **200:** Metadata retrieved successfully.
+    - **400:** Invalid prompt or input data.
+    - **500:** Internal server error.
     """
     try:
-        prompt = request.prompt
-        logger.info(f"Given prompt : {prompt}")
-        # prompt = prompt[-1] if isinstance(prompt, list) else prompt
-        embedding = embedding_service.get_text_embedding(prompt)
-        metadata = pinecone_service.retrieve_relevant_metadata(embedding, prompt, request.n_result, request.score_threshold)
-        return {"metadata": metadata}
+        if not request.prompt.strip():
+            raise HTTPException(status_code=400, detail="Prompt cannot be empty.")
+        logger.info(f"Fetching metadata for prompt: {request.prompt}")
+        embedding = embedding_service.get_text_embedding(request.prompt)
+        if not embedding:
+            raise HTTPException(status_code=400, detail="Failed to generate embedding for the given prompt.")
+        metadata = pinecone_service.retrieve_relevant_metadata(
+            embedding, 
+            request.prompt, 
+            request.n_result, 
+            request.score_threshold
+        )
+        if not metadata:
+            raise HTTPException(status_code=404, detail="No relevant metadata found.")
+
+        logger.info(f"Successfully fetched metadata for prompt: {request.prompt}")
+        return JSONResponse(content={"metadata": metadata}, status_code=200)
+    
+    except (ValueError, KeyError) as e:
+        logger.error(f"Invalid data format for metadata fetch: {e}")
+        raise HTTPException(status_code=400, detail=f"Invalid data format: {e}")
+    
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to fetch metadata: {e}")
+        logger.error(f"Unexpected error while fetching metadata: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch metadata due to an unexpected error.")

src/backend/main.py

@@ -3,7 +3,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from datetime import datetime
 from api_routes.chat_api import router as chat_router
 from api_routes.knowledge_base_api import router as knowledge_base_router
-from api_routes.chat_history_db_api import router as chat_history_router
+from api_routes.chat_history_supabase_api import router as chat_history_router
 
 description = (
     "Yuvabe Care Companion AI is designed to provide helpful and accurate "

src/backend/services/llm_model_service.py

@@ -73,15 +73,17 @@ def build_prompt(
     """
     conversation_history = truncate_conversation_history(conversation_history)
 
-    if db_response and "No relevant information found" not in db_response:
+    if db_response and db_response.strip() and "No relevant information found" not in db_response:
         return SYSTEM_PROMPT + conversation_history + [
-            {"role":"system", "content":f"{db_response}Please provide a detailed response based on the above information.If its relevant to the user query"},
+            {"role": "system", "content": (f"Here is some context from the database: {db_response}. "
+                                               "If this information is relevant to the user's query, please use it to form your response. "
+                                               "Otherwise, rely on your own knowledge and expertise.")},
             {"role": "user", "content": user_query}
         ]
 
     backup_response = (
-        "I'm unable to find relevant data from the database. "
-        "Please respond based on your expertise and available information."
+        "I couldn't find specific data from the database. "
+        "Please provide a detailed response based on your expertise and available information."
     )
     return SYSTEM_PROMPT + conversation_history + [
         {"role": "system", "content": backup_response},
@@ -116,7 +118,6 @@ def get_health_advice(
         )
 
         assistant_reply = response.choices[0].message.content.strip()
-        logger.info(f"Generated response: {assistant_reply}")
         return assistant_reply
 
     except (ConnectionError, TimeoutError) as e:

src/backend/services/pinecone_service.py

@@ -92,7 +92,7 @@ def initialize_pinecone_index(pinecone, index_name, dimension=384, metric="cosin
     except Exception as e:
         logger.error(f"Error occurred while getting or creating the Pinecone index: {str(e)}", exc_info=True)
         return None
-
+    
 index = initialize_pinecone_index(PINECONE, INDEX_NAME)
     
 def delete_records_by_ids(ids_to_delete):

src/backend/services/schemas.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel
-from typing import List,Dict, Optional
+from typing import List
 
 class ConversationInput(BaseModel):
     conversation_history: list[dict]
@@ -8,18 +8,8 @@ class ChatHistoryRequest(BaseModel):
     conversation_id: str
     messages: List[dict]
 
-
-
-
-
-
-
-class Chat_Response(BaseModel):
-    prompt: Optional[List] = None
-    response: Optional[Dict] = None
-
 class UpsertRequest(BaseModel):
-    data: list  # Expecting a list of JSON objects (rows of data)
+    data: list
 
 class DeleteRequest(BaseModel):
     ids_to_delete: list
@@ -27,13 +17,4 @@ class DeleteRequest(BaseModel):
 class MetadataRequest(BaseModel):
     prompt: str
     n_result: int = 3
-    score_threshold: float = 0.45
-
-class ChatRequest(BaseModel):
-    query: str
-
-class ChatResponse(BaseModel):
-    response: str
-
-class ChatHistoryResponse(BaseModel):
-    date: str
+    score_threshold: float = 0.45

src/backend/services/supabase_service.py

@@ -1,76 +1,140 @@
 import json
 import os
-import sys
-src_directory = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..", "backend"))
-sys.path.append(src_directory)
-from supabase import create_client
 from datetime import datetime
+from supabase import create_client, StorageException
 from utils import logger
+from dotenv import load_dotenv
 
+# Logger Initialization
+logger = logger.get_logger()
+
+# Load Environment Variables
+load_dotenv()
 SUPABASE_URL = os.getenv('SUPABASE_URL')
-SUPABASE_KEY = os.getenv('SUPABASE_KEY') 
+SUPABASE_KEY = os.getenv('SUPABASE_KEY')
 SUPABASE_BUCKET = os.getenv('SUPABASE_BUCKET')
-LLM_MODEL_NAME= os.getenv('LLM_MODEL_NAME')
-
-logger = logger.get_logger()
+LLM_MODEL_NAME = os.getenv('LLM_MODEL_NAME')
 
+# Supabase Client Initialization
 supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
 
-def store_chat_history(conversation_id, new_messages):
+# File Path Generator
+def _get_file_path(conversation_id: str) -> str:
+    """
+    Generates the file path for storing chat history JSON files.
+
+    Args:
+        conversation_id (str): Unique identifier for the conversation.
+
+    Returns:
+        str: Path to the chat history JSON file.
+    """
+    return f"chat-history/{conversation_id}.json"
+
+# JSON Loader with Safe Handling
+def _load_json(data: bytes) -> dict:
+    """
+    Safely loads JSON data from a byte stream.
+
+    Args:
+        data (bytes): The byte stream to decode and parse as JSON.
+
+    Returns:
+        dict: Parsed JSON data or an empty dictionary on failure.
+    """
+    try:
+        return json.loads(data.decode('utf-8'))
+    except (json.JSONDecodeError, AttributeError):
+        logger.error("Failed to decode JSON data.")
+        return {}
+
+# JSON Dumper with Indentation
+def _dump_json(data: dict) -> str:
+    """
+    Formats data as a JSON string with indentation for better readability.
+
+    Args:
+        data (dict): The data to format.
+
+    Returns:
+        str: Formatted JSON string.
+    """
+    return json.dumps(data, indent=4)
+
+def store_chat_history(conversation_id: str, new_messages: list) -> dict:
+    """
+    Stores or updates chat history in Supabase storage. If the file exists,
+    appends new messages; otherwise, creates a new file.
+
+    Args:
+        conversation_id (str): Unique identifier for the conversation.
+        new_messages (list): List of chat messages to store.
+
+    Returns:
+        dict: Operation success status and related message.
+    """
     try:
-        file_path = f"chat-history/{conversation_id}.json"
+        file_path = _get_file_path(conversation_id)
         metadata = {
             "timestamp": datetime.now().isoformat(),
             "language": "en",
             "model": LLM_MODEL_NAME
         }
 
+        # Load Existing Data
         try:
             existing_data = supabase.storage.from_(SUPABASE_BUCKET).download(file_path)
-            chat_data = json.loads(existing_data.decode('utf-8'))
+            chat_data = _load_json(existing_data)
+            if 'messages' not in chat_data:
+                chat_data['messages'] = []
             chat_data['messages'].extend(new_messages)
-            logger.info("Added the messages to the existing file")
-        except Exception:
+            logger.info(f"Messages appended to existing file for conversation ID: {conversation_id}")
+        except StorageException as e:
+            logger.warning(f"No existing file found. Creating new one for ID: {conversation_id}")
             chat_data = {
                 "conversation_id": conversation_id,
                 "messages": new_messages,
                 "metadata": metadata
             }
-            logger.info("Created a new chat history file.")
-
-        updated_json_data = json.dumps(chat_data, indent=4)
 
+        updated_json_data = _dump_json(chat_data)
         supabase.storage.from_(SUPABASE_BUCKET).upload(
             file_path, updated_json_data.encode('utf-8'),
             file_options={"content-type": "application/json", "upsert": "true"}
         )
-        logger.info("Chat history stored successfully!")
 
-        return {"message": "Chat history stored successfully!"}
+        return {"success": True, "message": "Chat history stored successfully."}
 
+    except StorageException as e:
+        logger.error(f"Supabase Storage error: {e}")
+        return {"success": False, "error": "Failed to store chat history. Storage error occurred."}
     except Exception as e:
-        logger.error(f"Error: {e}")
-        return {"error": str(e)}
+        logger.error(f"Unexpected error while storing chat history: {e}")
+        return {"success": False, "error": "Unexpected error occurred while storing chat history."}
 
-def get_chat_history(conversation_id):
+def retrieve_chat_history(conversation_id: str) -> dict:
+    """
+    Retrieves chat history from Supabase storage based on the given conversation ID.
+
+    Args:
+        conversation_id (str): Unique identifier for the conversation.
+
+    Returns:
+        dict: Retrieved chat data or error message on failure.
+    """
     try:
-        file_path = f"chat-history/{conversation_id}.json"
+        file_path = _get_file_path(conversation_id)
         existing_data = supabase.storage.from_(SUPABASE_BUCKET).download(file_path)
-        
-        if existing_data:
-            chat_data = json.loads(existing_data.decode('utf-8'))
-            return chat_data
-        else:
-            logger.warning("No chat history found for the given conversation ID.")
-            return {"message": "No chat history found."}
 
-    except Exception as e:
-        logger.error(f"Error retrieving chat history: {e}")
-        return {"error": str(e)}
+        if not existing_data:
+            logger.warning(f"No chat history found for ID: {conversation_id}")
+            return {"success": False, "message": "No chat history found."}
 
-def create_bucket_with_file(bucket_name:str):
-    try:
-        supabase.storage.create_bucket(bucket_name)
-        logger.info(f"Bucket '{bucket_name}' created successfully.")
+        return {"success": True, "data": _load_json(existing_data)}
+
+    except StorageException as e:
+        logger.error(f"Supabase Storage error while retrieving chat history: {e}")
+        return {"success": False, "error": "Failed to retrieve chat history. Storage error occurred."}
     except Exception as e:
-        logger.error(f"Error creating bucket: {e}")
+        logger.error(f"Unexpected error retrieving chat history for ID {conversation_id}: {e}")
+        return {"success": False, "error": "Unexpected error occurred while retrieving chat history."}

src/frontend/app/common_functions.py

@@ -37,7 +37,7 @@ def config_homepage(page_title=PAGE_TITLE):
 def set_page_title(page_title=PAGE_TITLE):
     st.markdown(f"""
         <h1 style="color: white; text-align: left; font-size: 42px;">
-        <i>{PAGE_TITLE} 🏥⚕️🤖</i>
+        <i>{PAGE_TITLE} ⚕️</i>
         </h1>
         """, unsafe_allow_html=True
     )
@@ -141,7 +141,7 @@ def fetch_response(prompt, chat_history):
     
 def store_chat_history_in_db(conversation_id, messages):
     try:
-        API_URL = f"http://localhost:8000/chat-db/store-history"
+        API_URL = f"http://localhost:8000/chat-history/store"
         payload = {"conversation_id": conversation_id, 'messages': messages}
         response = requests.post(API_URL, json=payload)
         logger.info("Successfully added the chat in db")
@@ -149,7 +149,7 @@ def store_chat_history_in_db(conversation_id, messages):
         logger.info(f"Failed to add the chat in db {e}")
 
 def get_chat_history_from_db(conversation_id: str, retries=3, delay=5):
-    API_URL = "http://127.0.0.1:8000/chat-db/get-history"
+    API_URL = "http://127.0.0.1:8000/chat-history/retrieve"
     for attempt in range(retries):
         try:
             response = requests.get(API_URL, params={"conversation_id": conversation_id}, timeout=30)
@@ -171,24 +171,35 @@ def display_chat_history(conversation_id):
         with st.spinner("Fetching chat history..."):
             chat_history = get_chat_history_from_db(conversation_id)
             
-            if not chat_history or "messages" not in chat_history or not chat_history["messages"]:
+            if not chat_history or "data" not in chat_history or not chat_history["data"].get("messages"):
                 st.error("No chat history found for this conversation.")
                 return
-
-            first_message_content = chat_history["messages"][0].get('content', '').strip()
+            
+            first_message_content = chat_history["data"]["messages"][0].get('content', '').strip()
             button_text = first_message_content[:20] if first_message_content else "No Content"
 
             if st.sidebar.button(f"Show History for {button_text}", key=f"show_history_{conversation_id}"):
                 st.subheader(f"Chat History for Conversation ID: {conversation_id}")
-                for message in chat_history["messages"]:
-                    if message['role'] == 'user':
-                        with st.chat_message('user'):
-                            st.write(message['role'])
-                            st.write(message['content'])
-                    elif message['role'] == 'assistant':
-                        with st.chat_message('assistant'):
-                            st.write(message['role'])
-                            st.write(message['content'])
+
+                for message in chat_history["data"]["messages"]:
+                    role = message.get('role', '').capitalize()
+                    content = message.get('content', '').strip()
+
+                    if role == 'User':
+                        st.markdown(f"**{role}:** {content}")
+                    elif role == 'Assistant':
+                        st.markdown(f"""
+                                    <div style="
+                                        background-color: #f0f2f6; 
+                                        padding: 15px; 
+                                        border-left: 5px solid #4CAF50; 
+                                        border-radius: 8px; 
+                                        margin-bottom: 10px;
+                                        box-shadow: 2px 2px 8px rgba(0, 0, 0, 0.1);">
+                                        <strong style="color: #333; font-size: 16px;">{role}:</strong>
+                                        <div style="margin-top: 5px; color: #555; font-size: 14px;">{content}</div>
+                                    </div>
+                                """, unsafe_allow_html=True)
 
     except Exception as e:
         logger.error(f"Error retrieving chat history for {conversation_id}: {e}")

src/frontend/pages/chatbot.py

@@ -7,6 +7,7 @@ API_URL = "http://localhost:8000/chat/get-health-advice/"
 NUMBER_OF_MESSAGES_TO_DISPLAY = 20
 common_functions.config_homepage()
 common_functions.set_page_title()
+common_functions.set_bg_image("src/frontend/images/health_care_baner_3.gif")
 # Initialize conversation history
 def initialize_conversation():
     assistant_message = ("Hello! I am your Yuvabe Care Companion AI, here to assist you with general medicine queries. "