create a branch for chat feature

README.md

@@ -100,3 +100,20 @@ Once launched, interact with Yuvabe Care Companion AI as follows:
 ## Contributions
 
 If you'd like to contribute to Yuvabe Care Companion AI, please fork the repository and create a pull request with your features or fixes.
+
+📋 Recommended Tech Stack (Enhanced)
+Library/Framework	Purpose
+streamlit	For building the chatbot UI with a simple and interactive interface.
+fastapi[standard]	For creating scalable APIs to manage backend logic and endpoints.
+uvicorn	Fast ASGI server for running FastAPI apps.
+requests	For making HTTP requests (e.g., fetching data from APIs).
+Pillow	For handling and processing images in chat responses (if needed).
+pandas	For data manipulation and analysis.
+torch, torchvision, torchaudio	For model inference and custom model development (if required).
+transformers	For powerful NLP models like GPT, LLaMA, or Mistral.
+sentence_transformers	For efficient text embeddings.
+groq	For ultra-fast model inference.
+sentence-transformers	For additional embedding options and fine-tuning.
+pinecone-client	For vector search and storage (ideal for RAG architecture).
+supabase	For efficient, scalable chat history storage.
+langchain	For implementing text chunking, prompt chaining, and retrieval pipelines

requirements.txt

@@ -3,10 +3,13 @@ requests
 Pillow
 pandas
 fastapi[standard]
-pinecone
 torch
 torchvision
 torchaudio
 transformers
-sentence_transformers
-groq
+groq
+sentence-transformers
+pinecone
+supabase
+langchain
+uvicorn

src/backend/api_routes/chat_api.py

@@ -0,0 +1,33 @@
+from fastapi import APIRouter, HTTPException
+from chatbot import chatbot_response
+from services import pinecone_service,llm_model_service
+from services.supabase_service import get_chat_history
+from utils import logger
+from services.schemas import ChatRequest,ChatResponse
+
+
+
+logger= logger.get_logger()
+
+router = APIRouter(prefix="/chat", tags=["Chat"])
+
+
+@router.post("/query")
+async def chat_query(request: ChatRequest):
+    try:
+        logger.info("Trying to fetch response")
+        query = request.query
+        context = pinecone_service.retrieve_context_from_pinecone(query)
+        response= llm_model_service.generate_response_with_context(query,context)
+        logger.info("Fetched response")
+        return response
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# @router.get("/history/{date}", response_model=list)
+# async def get_history(date: str):
+#     try:
+#         history = get_chat_history(date)
+#         return history
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))

src/backend/{routes → api_routes}/knowledge_base_api.py

@@ -4,7 +4,7 @@ from models.schemas import UpsertRequest,DeleteRequest,MetadataRequest
 from data import pinecone_db
 import pandas as pd
 
-router = APIRouter()
+router = APIRouter(prefix="/knowledge-base", tags=['Knowledge Base Operations'])
 
 @router.post("/upsert-data")
 def upsert_data(request: UpsertRequest):

src/backend/chatbot.py

@@ -0,0 +1,21 @@
+from services.pinecone_service import retrieve_relevant_metadata
+from services.supabase_service import store_chat_history
+from sentence_transformers import CrossEncoder
+
+reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+
+def rerank_results(query, results):
+    pairs = [(query, result["metadata"]["text"]) for result in results]
+    scores = reranker.predict(pairs)
+    return [x for _, x in sorted(zip(scores, results), key=lambda pair: pair[0], reverse=True)]
+
+def chatbot_response(query):
+    results = retrieve_relevant_metadata(query)
+    if results:
+        reranked_results = rerank_results(query, results)
+        best_answer = reranked_results[0]["metadata"]["question"]
+    else:
+        best_answer = "I'm sorry, I couldn't find an answer for your query."
+
+    # store_chat_history(query, best_answer)
+    return best_answer

src/backend/data/pinecone_db.py

@@ -4,7 +4,7 @@ import os
 # sys.path.append(src_directory)
 from pinecone import Pinecone, ServerlessSpec
 import time
-from tqdm import tqdm  # Progress bar for large datasets
+from tqdm import tqdm
 from dotenv import load_dotenv
 from utils import logger
 import pandas as pd

src/backend/main.py

@@ -1,33 +1,46 @@
-from fastapi import FastAPI
-from routes import knowledge_base_api
-from fastapi.middleware.cors import CORSMiddleware
-from utils import logger 
+# from fastapi import FastAPI
+# from routes import knowledge_base_api
+# from fastapi.middleware.cors import CORSMiddleware
+# from utils import logger 
 
-# Initialize FastAPI app
-app = FastAPI(
-    title="HealthCare VectorDB API",
-    description="API for managing Pinecone VectorDB operations for healthcare data.",
-    version="1.0.0"
-)
+# # Initialize FastAPI app
+# app = FastAPI(
+#     title="HealthCare VectorDB API",
+#     description="API for managing Pinecone VectorDB operations for healthcare data.",
+#     version="1.0.0"
+# )
 
-# Logger setup
-logger = logger.get_logger()
+# # Logger setup
+# logger = logger.get_logger()
 
-# CORS Middleware (for better cross-origin request handling)
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Adjust for security if needed
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+# # CORS Middleware (for better cross-origin request handling)
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],  # Adjust for security if needed
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# # Include API routes
+# app.include_router(knowledge_base_api.router, prefix="/knowledge-base", tags=['Knowledge Base Operations'])
 
-# Include API routes
-app.include_router(knowledge_base_api.router, prefix="/knowledge-base", tags=['Knowledge Base Operations'])
 
+# # Health Check Endpoint
+# @app.get("/health", tags=["Health Check"])
+# async def health_check():
+#     return {"status": "API is healthy and running."}
 
-# Health Check Endpoint
-@app.get("/health", tags=["Health Check"])
-async def health_check():
-    return {"status": "API is healthy and running."}
+from fastapi import FastAPI
+from api_routes.chat_api import router as chat_router
+from api_routes.knowledge_base_api import router as knowledge_base_router
+
+app = FastAPI(
+    title="Yuvabe Care Companion AI",
+    description="A chatbot for health-related queries",
+    version="1.0.0"
+)
 
+# Register Routes
+app.include_router(chat_router)
+app.include_router(knowledge_base_router)

src/backend/models/schemas.py

@@ -14,4 +14,13 @@ class DeleteRequest(BaseModel):
 class MetadataRequest(BaseModel):
     prompt: str
     n_result: int = 3
-    score_threshold: float = 0.45
+    score_threshold: float = 0.45
+
+class ChatRequest(BaseModel):
+    query: str
+
+class ChatResponse(BaseModel):
+    response: str
+
+class ChatHistoryResponse(BaseModel):
+    date: str

src/backend/services/embedding_service.py

@@ -0,0 +1,18 @@
+from sentence_transformers import SentenceTransformer
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from utils import logger
+
+logger = logger.get_logger()
+
+model = SentenceTransformer("all-MiniLM-L6-v2")
+
+def get_text_embedding(text):
+    try:
+        return model.encode(text, convert_to_tensor=True).cpu().numpy().tolist()
+    except Exception as e:
+        logger.error(f"Error generating embedding: {e}")
+        raise
+
+def chunk_text(text, chunk_size=500, chunk_overlap=100):
+    splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+    return splitter.split_text(text)

src/backend/services/llm_model_service.py

@@ -0,0 +1,33 @@
+import os
+from groq import Groq
+from dotenv import load_dotenv
+
+load_dotenv()
+
+LLM_MODEL_NAME="llama-3.3-70b-versatile"
+GROQ_KEY = os.environ.get("GROQ_API")
+client = Groq(api_key=GROQ_KEY)
+
+
+def generate_response_with_context(prompt, context):
+    # Construct the final prompt for the LLaMA model
+    final_prompt = (
+        f"Context: {context}\n\n"
+        f"Question: {prompt}\n"
+        "Answer:"
+    )
+
+    # Send the prompt to the Groq API
+    chat_completion = client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": final_prompt},
+                {"role": "user", "content": prompt},
+            ],
+            model=LLM_MODEL_NAME,
+        )
+
+    assistant_response = chat_completion.choices[0].message.content
+
+    # Extract the response text
+    return assistant_response
+

src/backend/services/pinecone_service.py

@@ -0,0 +1,251 @@
+import os
+# import sys
+# src_directory = os.path.abspath(os.path.join(os.path.dirname(__file__), "../..", "backend"))
+# sys.path.append(src_directory)
+from pinecone import Pinecone, ServerlessSpec
+import time
+from tqdm import tqdm
+from dotenv import load_dotenv
+from utils import logger
+import pandas as pd
+from services.embedding_service import get_text_embedding
+from sentence_transformers import CrossEncoder
+
+reranker = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+
+load_dotenv()
+PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
+logger = logger.get_logger()
+NAMESPACE = "health-care-dataset"
+INDEX_NAME = "health-care-index"
+PINECONE = Pinecone(api_key=PINECONE_API_KEY)
+
+def rerank_results(query, results, score_threshold=0.5):
+    pairs = [(query, result["metadata"]["question"]) for result in results]
+    scores = reranker.predict(pairs)
+    
+    # Filter based on score threshold
+    filtered_results = [
+        result for score, result in zip(scores, results) if score >= score_threshold
+    ]
+    
+    # Sort remaining results by score in descending order
+    return sorted(filtered_results, key=lambda x: x['score'], reverse=True)
+
+def initialize_pinecone_index(pinecone, index_name, dimension=384, metric="cosine", cloud="aws", region="us-east-1"):
+    """
+    Retrieves an existing Pinecone index or creates a new one if it does not exist.
+
+    This method checks for the presence of the specified index. If the index does not exist,
+    it initiates the creation process, waits until the index is ready, and then returns the index.
+
+    Args:
+        pinecone (Pinecone): Pinecone client instance.
+        index_name (str): Name of the index to retrieve or create.
+        dimension (int, optional): Vector dimension for the index. Default is 384.
+        metric (str, optional): Distance metric for the index. Default is "cosine".
+        cloud (str, optional): Cloud provider for hosting the index. Default is "aws".
+        region (str, optional): Region where the index will be hosted. Default is "us-east-1".
+
+    Returns:
+        pinecone.Index: The Pinecone index instance.
+
+    Raises:
+        Exception: If an error occurs during index creation or retrieval.
+
+    Example:
+        >>> index = get_or_create_index(pinecone, "sample_index")
+        Logs: "Index 'sample_index' is ready and accessible."
+    """
+    try:
+        logger.info(f"Checking if the index '{index_name}' exists...")
+
+        # Check if index already exists
+        if not pinecone.has_index(index_name):
+            logger.info(f"Index '{index_name}' does not exist. Creating a new index...")
+
+            # Create a new index
+            pinecone.create_index(
+                name=index_name,
+                dimension=dimension,
+                metric=metric,
+                spec=ServerlessSpec(cloud=cloud, region=region)
+            )
+            logger.info(f"Index '{index_name}' creation initiated. Waiting for it to be ready...")
+
+            # Wait until index is ready
+            while True:
+                index_status = pinecone.describe_index(index_name)
+                if index_status.status.get("ready", False):
+                    index = pinecone.Index(index_name)
+                    logger.info(f"Index '{index_name}' is ready and accessible.")
+                    return index
+                else:
+                    logger.debug(f"Index '{index_name}' is not ready yet. Checking again in 1 second.")
+                    time.sleep(1)
+        else:
+            # Return the existing index
+            index = pinecone.Index(index_name)
+            logger.info(f"Index '{index_name}' already exists. Returning the existing index.")
+            return index
+
+    except Exception as e:
+        logger.error(f"Error occurred while getting or creating the Pinecone index: {str(e)}", exc_info=True)
+        return None
+    
+def delete_records_by_ids(ids_to_delete):
+    """
+    Deletes specified IDs from the database index.
+
+    This method interacts with the index to delete entries based on the provided list of IDs.
+    It logs a success message if the deletion is successful or returns an error message if it fails.
+
+    Args:
+        ids_to_delete (list): 
+            A list of unique identifiers (IDs) to be deleted from the database.
+
+    Returns:
+        str: A success message is logged upon successful deletion.
+             If an error occurs, a string describing the failure is returned.
+
+    Raises:
+        Exception: Logs an error if the deletion process encounters an issue.
+
+    Example:
+        >>> remove_ids_from_database(['id_123', 'id_456'])
+        Logs: "IDs deleted successfully."
+
+    Notes:
+        - The method assumes `get_index()` initializes the index object.
+        - Deletion occurs within the specified `NAMESPACE`.
+    """
+    try:
+        index = initialize_pinecone_index(PINECONE,INDEX_NAME)
+        index.delete(ids=ids_to_delete, namespace=NAMESPACE)
+        logger.info("IDs deleted successfully.")
+    except Exception as e:
+        return f"Failed to delete the IDs: {e}"
+
+def retrieve_relevant_metadata(prompt, n_result=3, score_threshold=0.47):
+    """
+    Retrieves and reranks relevant context data based on a given prompt.
+    """
+    try:
+        index = initialize_pinecone_index(PINECONE, INDEX_NAME)
+        prompt = prompt[-1] if isinstance(prompt, list) else prompt
+
+        # Generate embedding for the provided prompt
+        embedding = get_text_embedding(prompt)
+        response = index.query(
+            top_k=n_result,
+            vector=embedding,
+            namespace=NAMESPACE,
+            include_metadata=True
+        )
+
+        # Extract metadata and filter by score threshold
+        filtered_results = [
+            {
+                "question": entry.get('metadata', {}).get('question', 'N/A'),
+                "answer": entry.get('metadata', {}).get('answer', 'N/A'),
+                "instruction": entry.get('metadata', {}).get('instruction', 'N/A'),
+                "score": f"{entry.get('score', 0)}",
+                "id": f"{entry.get('id', 'N/A')}"
+            }
+            for entry in response.get('matches', [])
+            if entry.get('score', 0) >= score_threshold
+        ]
+
+        # Rerank the filtered results using a reranker model
+        if filtered_results:
+            pairs = [(prompt, item["question"]) for item in filtered_results]
+            scores = reranker.predict(pairs)  # Predict relevance scores
+
+            # Attach reranker scores and sort by relevance
+            for item, score in zip(filtered_results, scores):
+                item["reranker_score"] = score
+
+            filtered_results = sorted(
+                filtered_results, 
+                key=lambda x: x["reranker_score"], 
+                reverse=True
+            )
+
+        # Return metadata or fallback message
+        return filtered_results if filtered_results else [{"response": "No relevant data found."}]
+
+    except Exception as e:
+        logger.error(f"Failed to fetch context for '{prompt[:20]}'. Error: {e}")
+        return [{"response": "Failed to fetch data due to an error."}]
+
+
+def upsert_vector_data(df: pd.DataFrame):
+
+    """
+    Generates embeddings for the given DataFrame and uploads data to Pinecone in batches.
+    
+    Parameters:
+    - df (pd.DataFrame): DataFrame containing 'input', 'question', and 'answer' columns.
+    
+    Returns:
+    - None
+    """
+
+    try:
+        index = initialize_pinecone_index(PINECONE,INDEX_NAME)
+        df["embedding"] = [
+            get_text_embedding([q])[0] 
+            for q in tqdm(df["input"], desc="Generating Embeddings")
+        ]
+    except Exception as e:
+        logger.error(f"Error generating embeddings: {e}")
+        return
+
+    # # Upload data to Pinecone in batches
+    BATCH_SIZE = 500
+
+    for i in tqdm(range(0, len(df), BATCH_SIZE), desc="Uploading Data to Pinecone"):
+        batch = df.iloc[i : i + BATCH_SIZE]
+    
+        vectors = []
+        for idx, (embedding, (_, row_data)) in enumerate(zip(batch["embedding"], batch.iterrows())):
+            question = row_data.get("input")
+            vector_id = f"{question[:50]}:{i + idx}"  # Ensures IDs remain unique across 
+            metadata = {
+                "question": row_data.get("input"),
+                "answer": row_data.get("output"),
+                "instruction": row_data.get("instruction"),
+            }
+            vectors.append((vector_id, embedding, metadata))
+
+        try:
+            index.upsert(vectors=vectors,namespace=NAMESPACE)
+        except Exception as e:
+            logger.error(f"Error uploading batch starting at index {i}: {e}")
+
+    logger.info("All question-answer pairs stored successfully!")
+
+def retrieve_context_from_pinecone(prompt, n_result=3, score_threshold=0.5):
+
+    index = initialize_pinecone_index(PINECONE,INDEX_NAME)
+    # Generate embedding for the provided prompt
+    embedding = get_text_embedding(prompt)
+    # Query Pinecone for relevant context
+    response = index.query(
+        top_k=n_result,
+        vector=embedding,
+        namespace="your_namespace",
+        include_metadata=True
+    )
+
+    # Extract metadata and filter results
+    filtered_results = [
+        entry['metadata'].get('question', 'N/A')
+        for entry in response.get('matches', [])
+        if entry.get('score', 0) >= score_threshold
+    ]
+
+    # Combine the context into a single string
+    context = "\n".join(filtered_results) if filtered_results else "No relevant context found."
+    
+    return context

src/backend/services/schemas.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class ChatRequest(BaseModel):
+    query: str = Field(..., description="User's query for the chatbot")
+
+class ChatResponse(BaseModel):
+    response: str = Field(..., description="Response generated by the chatbot")
+
+class ChatHistoryResponse(BaseModel):
+    date: str = Field(..., description="Date of the chat history in 'YYYY-MM-DD' format")

src/backend/services/supabase_service.py

@@ -0,0 +1,46 @@
+import json
+import os
+from supabase import create_client, Client
+from datetime import datetime
+from utils import logger
+
+SUPABASE_URL = os.getenv('SUPABASE_URL')
+SUPABASE_KEY = os.getenv('SUPABASE_KEY') 
+SUPABASE_BUCKET = os.getenv('SUPABASE_BUCKET')
+
+logger = logger.get_logger()
+
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+def store_chat_history(user_query, bot_response):
+    today = datetime.now().strftime("%Y-%m-%d")
+    file_path = f"{today}/{datetime.now().isoformat()}.json"
+
+    chat_data = {
+        "timestamp": datetime.now().isoformat(),
+        "user_query": user_query,
+        "bot_response": bot_response
+    }
+
+    try:
+        supabase.storage.from_(SUPABASE_BUCKET).upload(file_path, json.dumps(chat_data).encode('utf-8'))
+        logger.info(f"Chat history stored successfully: {file_path}")
+    except Exception as e:
+        logger.error(f"Error storing chat history: {e}")
+
+def get_chat_history(date):
+    try:
+        prefix = f"{date}/"
+        files = supabase.storage.from_(SUPABASE_BUCKET).list(prefix)
+        chat_history = []
+
+        for file in files:
+            file_path = file['name']
+            response = supabase.storage.from_(SUPABASE_BUCKET).download(file_path)
+            chat_data = json.loads(response)
+            chat_history.append(chat_data)
+
+        return chat_history
+    except Exception as e:
+        logger.error(f"Error retrieving chat history: {e}")
+        return []