Upload 4 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Database.xlsx filter=lfs diff=lfs merge=lfs -text
+robot.gif filter=lfs diff=lfs merge=lfs -text

Database.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7c2f293c5ae6f596ac129e67d6bc264709a070e15ee5121f8272cd900114bbd
+size 1292016

main.py

@@ -0,0 +1,326 @@
+from fastapi import FastAPI, File, UploadFile
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+import os
+import openai
+from io import BytesIO
+from gtts import gTTS
+import tempfile
+from dotenv import load_dotenv
+from sentence_transformers import SentenceTransformer
+import math
+from collections import Counter
+import json
+import pandas as pd
+import asyncio
+import numpy as np
+from deepgram import Deepgram  # NEW
+
+load_dotenv()
+DEEPGRAM_API_KEY = os.getenv("DEEPGRAM_API_KEY")  # Add this to your .env
+dg_client = Deepgram(DEEPGRAM_API_KEY)  # Initialize Deepgram client
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+chat_messages = [{"role": "system", "content": '''
+        You are kammi, a friendly, human-like voice assistant built by Facile AI Solutions, headed by Deepti.You assist customers specifically with knee replacement surgery queries and you are the assistant of Dr.Sandeep who is a highly experienced knee replacement surgeon.
+
+        Rules for your responses:
+
+        1. **Context-driven answers only**: Answer strictly based on the provided context and previous conversation history. Do not use external knowledge. 
+
+        2. **General conversation**: Engage in greetings and casual conversation. If the user mentions their name, greet them personally and continue using their name.
+
+        3. **Technical/medical queries**:
+        - If the question is **relevant to knee replacement surgery** and the answer is in the context or chat history, provide the answer.
+        - If the question is **relevant but not present in the context**, respond: "please connect with Dr.Sandeep or Reception for this details."
+
+        4. **Irrelevant queries**:
+        - If the question is completely unrelated to knee replacement surgery, politely decline and respond: "I am here to assist only with knee replacement surgery related queries."
+
+        5. **Drive conversation**:
+        - After answering the user’s question, suggest a follow-up question from the context that you can answer. 
+        - Make the follow-up natural and conversational. The follow up question must be relevant to the current question or response
+        - If the user responds with confirmation like “yes”, “okay” give the answer for the previous follow-up question from the context.
+
+        6. **Readable voice output for gTTS**:
+        - Break sentences at natural punctuation: `, . ? ! : ;`.
+        - Do not use `#`, `**`, or other markdown symbols.
+        - Numbers and points must be spelled out: e.g., `2.5 lakh` → `two point five lakh`. Similarly Dr, Mr, Mrs, etc. must be written as Doctor, Mister, Misses etc. 
+        7. **Concise and human-like**:
+        - Keep answers short, conversational, and natural.
+        - Maximum 40 words / ~20 seconds of speech.
+
+        8. **Tone and style**:
+        - Helpful, friendly, approachable, and human-like.
+        - Maintain professionalism while being conversational.
+        
+        9. **About Dr.Sandeep**:
+        - He has over 15 years of experience in orthopedic and joint replacement surgery.
+        - He specializes in total and partial knee replacement procedures.
+        - Known for a patient-friendly approach, focusing on pre-surgery preparation, post-surgery rehabilitation, and pain management.
+        - Actively keeps up-to-date with the latest techniques and technologies in knee replacement surgery.
+        - Highly approachable and prefers that patients are well-informed about their treatment options and recovery process.
+
+        Always provide readable, streaming-friendly sentences so gTTS can read smoothly. Drive conversation forward while staying strictly on knee replacement surgery topics, and suggest follow-up questions for which you have context-based answers.
+'''}]
+
+class BM25:
+    def __init__(self, corpus, k1=1.2, b=0.75):
+        self.corpus = [doc.split() if isinstance(doc, str) else doc for doc in corpus]
+        self.k1 = k1
+        self.b = b
+        self.N = len(self.corpus)
+        self.avgdl = sum(len(doc) for doc in self.corpus) / self.N
+        self.doc_freqs = self._compute_doc_frequencies()
+        self.idf = self._compute_idf()
+
+    def _compute_doc_frequencies(self):
+        """Count how many documents contain each term"""
+        df = {}
+        for doc in self.corpus:
+            unique_terms = set(doc)
+            for term in unique_terms:
+                df[term] = df.get(term, 0) + 1
+        return df
+
+    def _compute_idf(self):
+        """Compute the IDF for each term in the corpus"""
+        idf = {}
+        for term, df in self.doc_freqs.items():
+            idf[term] = math.log((self.N - df + 0.5) / (df + 0.5) + 1)
+        return idf
+
+    def score(self, query, document):
+        """Compute the BM25 score for one document and one query"""
+        query_terms = query.split() if isinstance(query, str) else query
+        doc_terms = document.split() if isinstance(document, str) else document
+        score = 0.0
+        freqs = Counter(doc_terms)
+        doc_len = len(doc_terms)
+
+        for term in query_terms:
+            if term not in freqs:
+                continue
+            f = freqs[term]
+            idf = self.idf.get(term, 0)
+            denom = f + self.k1 * (1 - self.b + self.b * doc_len / self.avgdl)
+            score += idf * (f * (self.k1 + 1)) / denom
+        return score
+
+    def rank(self, query):
+        """Rank all documents for a given query"""
+        return [(i, self.score(query, doc)) for i, doc in enumerate(self.corpus)]
+
+
+def sigmoid_scaled(x, midpoint=3.0):
+    """
+    Sigmoid function with shifting.
+    `midpoint` controls where the output is 0.5.
+    """
+    return 1 / (1 + math.exp(-(x - midpoint)))
+
+def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
+
+    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
+
+async def compute_similarity(query: str, query_embedding: np.ndarray, chunk_text: str, chunk_embedding: np.ndarray, sem_weight: float,syn_weight:float,bm25) -> float:
+
+    semantic_score = cosine_similarity(query_embedding, chunk_embedding)
+
+    # syntactic_score = fuzz.ratio(query, chunk_text) / 100.0
+    syntactic_score = bm25.score(query,chunk_text)
+    final_syntactic_score = sigmoid_scaled(syntactic_score)
+
+    combined_score = sem_weight * semantic_score + syn_weight * final_syntactic_score
+
+    return combined_score
+
+async def retrieve_top_k_hybrid(query, k, sem_weight,syn_weight,bm25):
+
+    query_embedding = model.encode(query)
+
+    tasks = [
+
+        compute_similarity(query, query_embedding, row["Chunks"], row["Embeddings"] , sem_weight,syn_weight,bm25)
+
+        for _, row in df_expanded.iterrows()
+
+    ]
+
+    similarities = await asyncio.gather(*tasks)
+
+    df_expanded["similarity"] = similarities
+
+    top_results = df_expanded.sort_values(by="similarity", ascending=False).head(k)
+
+    return top_results["Chunks"].to_list()
+
+model = SentenceTransformer("abhinand/MedEmbed-large-v0.1")
+df_expanded = pd.read_excel("Database.xlsx")  # Replace with your filename
+df_expanded["Embeddings"] = df_expanded["Embeddings"].map(lambda x: json.loads(x))
+corpus = df_expanded['Chunks'].to_list()
+bm25 = BM25(corpus)
+
+
+# --- gTTS helper: stream raw audio file in small chunks ---
+def tts_chunk_stream(text_chunk: str, lang: str = "en"):
+    if not text_chunk.strip():
+        return []
+
+    tts = gTTS(text=text_chunk, lang=lang)
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+    tts.save(temp_file.name)
+
+    def audio_stream():
+        try:
+            with open(temp_file.name, "rb") as f:
+                chunk = f.read(1024)
+                while chunk:
+                    yield chunk
+                    chunk = f.read(1024)
+        finally:
+            try:
+                os.remove(temp_file.name)
+            except Exception:
+                pass
+
+    return audio_stream()
+
+async def get_rag_response(user_message: str):
+    global chat_messages
+    Chunks = await retrieve_top_k_hybrid(user_message,15, 0.9, 0.1,bm25)
+    context = "======================================================================================================\n".join(Chunks)
+    chat_messages.append({"role": "user", "content": f'''     
+          Context : {context}
+          User Query: {user_message}'''})
+    # print("chat_messages",chat_messages)
+    # response = get_response(query, context, chat_messages)
+    # chat_messages.append({"role": "assistant", "content": response})
+    return chat_messages
+
+
+# --- GPT + TTS async generator with smaller buffer like second code ---
+async def gpt_tts_stream(prompt: str):
+    print("started gpt_tts_stream",prompt)
+    global chat_messages
+    chat_messages = await get_rag_response(prompt)
+    # print(chat_messages,"chat_messages after getting RAG response")
+    response = openai.ChatCompletion.create(
+        model="gpt-4o",
+        messages= chat_messages,
+        stream=True
+    )
+    buffer = ""
+    BUFFER_SIZE = 20  # smaller buffer like second code
+    bot_response = ""
+
+    for chunk in response:
+        choices = chunk.get("choices", [])
+        if not choices:
+            continue
+
+        delta = choices[0]["delta"].get("content", "")
+        finish_reason = choices[0].get("finish_reason")
+        if delta:
+            bot_response = bot_response + delta
+            buffer += delta
+            if len(buffer) >= BUFFER_SIZE and buffer.endswith((".", "!",",", "?", "\n", ";", ":")):
+                for audio_chunk in tts_chunk_stream(buffer):
+                    print("chunk",buffer)
+                    yield audio_chunk
+                    buffer = ""
+
+        if finish_reason is not None:
+            break
+    
+    bot_response = bot_response.strip()
+    chat_messages.append({"role": "assistant", "content": bot_response})
+
+    if buffer.strip():
+        for audio_chunk in tts_chunk_stream(buffer):
+            yield audio_chunk
+
+@app.post("/chat_stream")
+async def chat_stream(file: UploadFile = File(...)):
+    audio_bytes = await file.read()
+
+    # Transcribe using Deepgram
+    response = await dg_client.transcription.prerecorded(
+        {
+            "buffer": audio_bytes,
+            "mimetype": "audio/webm" 
+        },
+        {
+            "model": "nova-3",  
+            "language": "en",
+            "punctuate": True,
+            "smart_format": True
+        }
+    )
+
+    transcript_text = response["results"]["channels"][0]["alternatives"][0]["transcript"].strip()
+
+    return StreamingResponse(gpt_tts_stream(transcript_text), media_type="audio/mpeg")
+
+
+@app.post("/reset_chat")
+async def reset_chat():
+    global chat_messages
+    chat_messages = [{
+        "role": "system",
+        "content": '''
+        You are kammi, a friendly, human-like voice assistant built by Facile AI Solutions, headed by Deepti.You assist customers specifically with knee replacement surgery queries and you are the assistant of Dr.Sandeep who is a highly experienced knee replacement surgeon.
+
+        Rules for your responses:
+
+        1. **Context-driven answers only**: Answer strictly based on the provided context and previous conversation history. Do not use external knowledge. 
+
+        2. **General conversation**: Engage in greetings and casual conversation. If the user mentions their name, greet them personally and continue using their name.
+
+        3. **Technical/medical queries**:
+        - If the question is **relevant to knee replacement surgery** and the answer is in the context or chat history, provide the answer.
+        - If the question is **relevant but not present in the context**, respond: "please connect with Dr.Sandeep or Reception for this details."
+
+        4. **Irrelevant queries**:
+        - If the question is completely unrelated to knee replacement surgery, politely decline and respond: "I am here to assist only with knee replacement surgery related queries."
+
+        5. **Drive conversation**:
+        - After answering the user’s question, suggest a follow-up question from the context that you can answer. 
+        - Make the follow-up natural and conversational. The follow up question must be relevant to the current question or response
+        - If the user responds with confirmation like “yes”, “okay” give the answer for the previous follow-up question from the context.
+
+        6. **Readable voice output for gTTS**:
+        - Break sentences at natural punctuation: `, . ? ! : ;`.
+        - Do not use `#`, `**`, or other markdown symbols.
+        - Numbers and points must be spelled out: e.g., `2.5 lakh` → `two point five lakh`. Similarly Dr, Mr, Mrs, etc. must be written as Doctor, Mister, Misses etc. 
+        7. **Concise and human-like**:
+        - Keep answers short, conversational, and natural.
+        - Maximum 40 words / ~20 seconds of speech.
+
+        8. **Tone and style**:
+        - Helpful, friendly, approachable, and human-like.
+        - Maintain professionalism while being conversational.
+
+        9. **About Dr.Sandeep**:
+        - He has over 15 years of experience in orthopedic and joint replacement surgery.
+        - He specializes in total and partial knee replacement procedures.
+        - Known for a patient-friendly approach, focusing on pre-surgery preparation, post-surgery rehabilitation, and pain management.
+        - Actively keeps up-to-date with the latest techniques and technologies in knee replacement surgery.
+        - Highly approachable and prefers that patients are well-informed about their treatment options and recovery process.
+
+        Always provide readable, streaming-friendly sentences so gTTS can read smoothly. Drive conversation forward while staying strictly on knee replacement surgery topics, and suggest follow-up questions for which you have context-based answers.
+'''
+    }]
+    return {"message": "Chat history reset successfully."}
+

requirements.txt

@@ -0,0 +1,15 @@
+uvicorn
+openai==0.28
+python-dotenv
+fastapi
+uvicorn[standard]
+python-multipart
+gTTS
+pydub
+aiofiles
+sentence-transformers
+pandas
+sentence-transformers
+openpyxl
+deepgram-sdk==2.12.0
+