Upload 5 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
+static/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:f1b2fa6e90d86a5446f7d192fe2b8060ce0dbcae7d4bfa11aa68b6e74774ba40
+size 1364411

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.11-slim
+
+# ---- Set environment variables (Updated here only for HF compatibility) ----
+ENV PYTHONUNBUFFERED=1
+ENV TRANSFORMERS_CACHE=/app/.cache/transformers
+ENV HF_HOME=/app/.cache/huggingface
+
+# ---- Optional: define keys via secrets, not hardcoded ----
+# ENV DEEPGRAM_API_KEY=your_key
+# ENV OPENAI_API_KEY=your_key
+
+# ---- Set working directory ----
+WORKDIR /app
+
+# Add below WORKDIR /app
+RUN mkdir -p /app/.cache/transformers /app/.cache/huggingface
+RUN chmod -R 777 /app/.cache
+
+# ---- Install system dependencies ----
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    build-essential \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+
+# ---- Copy project files ----
+COPY . /app
+
+# ---- Install Python dependencies ----
+RUN pip install --upgrade pip
+RUN pip install --no-cache-dir -r requirements.txt
+
+# ---- Expose port ----
+EXPOSE 7860
+
+# ---- Run FastAPI app ----
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,581 @@
+import os
+os.environ["TRANSFORMERS_CACHE"] = "/app/.cache/transformers"
+os.environ["HF_HOME"] = "/app/.cache/huggingface"
+
+
+from google.cloud import speech_v1p1beta1 as speech
+from google.cloud import translate_v2 as translate
+from pydub import AudioSegment
+import wave
+import uvicorn
+
+
+from fastapi import FastAPI, File, UploadFile
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+import openai
+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 
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
+import openai as _openai_mod
+import requests
+
+import time
+import wave
+from fastapi import UploadFile, File
+from starlette.responses import StreamingResponse
+from pydub import AudioSegment
+from google.cloud import speech_v1p1beta1 as speech
+from google.cloud import translate_v2 as translate
+from openai import OpenAI
+load_dotenv()
+
+client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+@app.get("/", response_class=HTMLResponse)
+async def serve_html():
+    with open("templates/index.html", "r", encoding="utf-8") as f:
+        html_content = f.read()
+    return HTMLResponse(content=html_content)
+
+
+chat_messages = [{"role": "system", "content": '''
+        You are Kammi, a friendly, medical assistant specializing in orthopedic surgery, human-like voice assistant built by Facile AI Solutions
+        You assist customers specifically with knee replacement surgery queries and you are the assistant of Dr.Sandeep, 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. Respond in **Telugu*.
+
+        2. *General conversation*: Engage in greetings and casual conversation. If the user mentions their name, greet them personally using their name, in Telugu.
+
+        3. *Technical/medical queries*:
+        Answer in *Telugu* based on the context or chat history.
+
+        - If the question is *relevant to knee replacement surgery and the answer is in the context or chat history, provide the answer in **Telugu*.
+        - If the question is *relevant but not present in the context*, respond: "దయచేసి డాక్టర్ సందీప్ లేదా రిసెప్షన్ ను సంప్రదించండి."
+
+        - Translate medical and technical terms into simple, **understandable conversational Telugu** wherever possible.
+        - The output must be in Telugu script, but common English medical or technical terms (like knee, hip, surgery, replacement, physiotherapy, arthritis, etc.)
+          should be written phonetically in Telugu, not translated literally.
+
+          Example:
+          “knee replacement” → మోకాలు రీప్లేస్‌మెంట్
+          “hip replacement” → హిప్ రీప్లేస్‌మెంట్
+          “surgery” → సర్జరీ
+          “physiotherapy” → ఫిజియోథెరపీ
+          Ensure the language sounds simple, natural, and conversational for Telugu-speaking patients.
+
+        4. *Irrelevant queries*:
+        - If the question is completely unrelated to knee replacement surgery, politely decline in Telugu: "నేను కేవలం మోకాలు రీప్లేస్‌మెంట్ సర్జరీ సంబంధిత ప్రశ్నలకు సహాయం చేస్తాను."
+
+        5. *Drive conversation*:
+        - After answering the user’s question, suggest a follow-up question from the context that you can answer, in *Telugu*
+        - Make the follow-up natural and conversational. The follow up question must be relevant to the current question or response in *Telugu*
+        - Do not include redundant statements like “మీరు మరింత సమాచారం కావాలనుకుంటే…”, "మీరు మరేదైనా అడగాలనుకుంటున్నారా" in the follow up questions
+        - If the user responds with confirmation like “yes”, “okay” give the answer for the previous follow-up question from the context.
+        - If the user ends the conversation, do not ask or suggest any follow-up question.
+
+
+        6. *Readable voice output for gTTS*:
+        - Break sentences at natural punctuation: , . ? ! : ;
+        - Do not use #, **, or other markdown symbols.
+          Telugu Output Guidelines:
+            All numbers, decimals, and points must be fully spelled out in Telugu words.
+            Example: 2.5 lakh → రెండు లక్షల యాభై వేల రూపాయలు
+
+        7. *Concise and human-like*:
+        - Keep answers short, conversational, and natural in *Telugu*.
+        - 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*:
+        - ALL the below points must be in *Telugu*
+        - Over 5 years of experience in orthopedic and joint replacement surgery.
+        - 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 in *Telugu* 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()
+
+
+os.makedirs("/tmp/transformers_cache", exist_ok=True)
+
+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()
+
+
+def tts_chunk_stream(text_chunk: str, lang: str = "en"):
+    """
+    REST-based OpenAI TTS fallback for older openai SDKs (e.g. 0.28).
+    Returns a generator yielding MP3 byte chunks (1024 bytes).
+    """
+    if not text_chunk or not text_chunk.strip():
+        return []
+
+    # Map short lang -> locale (extend if needed)
+    language_map = {
+        "en": "en-US",
+        "en-US": "en-US",
+        "en-GB": "en-GB",
+        "hi": "hi-IN",
+    }
+    language_code = language_map.get(lang, "en-GB")
+
+    # TTS model & voice choice
+    model = "gpt-4o-mini-tts"  # or "tts-1"
+    voice = "alloy"           # alloy, verse, shimmer, echo, coral
+    fmt = "mp3"
+
+    # Resolve API key (prefer openai.api_key if available)
+    api_key = None
+    try:
+        # if you set openai.api_key earlier in your code, prefer it
+        api_key = getattr(_openai_mod, "api_key", None)
+    except Exception:
+        api_key = None
+
+    if not api_key:
+        api_key = os.getenv("OPENAI_API_KEY")
+
+    if not api_key:
+        print("OpenAI API key not found. Set openai.api_key or env var OPENAI_API_KEY.")
+        return []
+
+    url = "https://api.openai.com/v1/audio/speech"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+    payload = {
+        "model": model,
+        "voice": voice,
+        "input": text_chunk,
+        "format": fmt
+        # "instructions" : "speak in cheerfull and positive tone"
+        # optional: "language": language_code   # include if needed by API variation
+    }
+
+    try:
+        # Use stream=True so we can yield bytes progressively.
+        resp = requests.post(url, headers=headers, json=payload, stream=True, timeout=60)
+    except Exception as e:
+        print("OpenAI TTS request failed:", e)
+        return []
+
+    if resp.status_code != 200:
+        # Try to show helpful error message
+        try:
+            err = resp.json()
+        except Exception:
+            err = resp.text
+        print(f"OpenAI TTS REST call failed {resp.status_code}: {err}")
+        try:
+            resp.close()
+        except Exception:
+            pass
+        return []
+
+    # At this point resp.iter_content yields raw mp3 bytes
+    def audio_stream():
+        try:
+            for chunk in resp.iter_content(chunk_size=1024):
+                if chunk:
+                    yield chunk
+        finally:
+            try:
+                resp.close()
+            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)
+    return chat_messages
+
+
+# --- GPT + TTS async generator with smaller buffer like second code ---
+async def gpt_tts_stream(prompt: str):
+    # start_time = time.time()
+    # 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
+    # )
+
+    bot_response = ""
+    buffer = ""
+    buffer_size = 30
+
+    # ✅ Must use the `with` block for streaming
+    with client.chat.completions.stream(
+        model="gpt-4o-mini",
+        messages=chat_messages,
+        ) as stream:
+
+        for event in stream:
+            if event.type == "content.delta":
+                delta = event.delta
+                bot_response = bot_response + delta
+                buffer += delta
+                if len(buffer) >= buffer_size and buffer.endswith((".", "!", ",", "?", "\n", ";", ":")):
+                    print("the buffer is ")
+                    print(buffer)
+                    # audio_chunks = tts_chunk_stream(buffer)
+                    for audio_chunk in tts_chunk_stream(buffer):
+                    # print("chunk",buffer)
+                        yield audio_chunk
+                        buffer = ""
+
+            elif event.type == "content.done":
+            # 🧾 model finished — flush whatever is left
+                if buffer.strip():
+                    print("the left over message")
+                    print(buffer.strip())
+                    for audio_chunk in tts_chunk_stream(buffer):
+                    # print("chunk",buffer)
+                        yield audio_chunk
+                        buffer = ""
+                    
+
+        bot_response = bot_response.strip()
+        chat_messages.append({"role": "assistant", "content": bot_response})
+
+
+
+
+# def convert_to_mono16_wav_bytes(audio_bytes: bytes) -> tuple[bytes, int]:
+#     print("i am inside the mono16 conversion")
+#     """Convert any uploaded audio (mp3/webm/wav) to mono 16-bit WAV bytes in memory."""
+#     audio = AudioSegment.from_file(io.BytesIO(audio_bytes))
+
+#     # Convert to mono
+#     if audio.channels != 1:
+#         audio = audio.set_channels(1)
+
+#     # Convert to 16-bit PCM
+#     if audio.sample_width != 2:
+#         audio = audio.set_sample_width(2)
+
+#     # Standardize sample rate to 16 kHz (required by Google STT)
+#     if audio.frame_rate != 16000:
+#         audio = audio.set_frame_rate(16000)
+
+#     # Export as in-memory WAV bytes
+#     wav_buffer = io.BytesIO()
+#     audio.export(wav_buffer, format="wav")
+#     wav_bytes = wav_buffer.getvalue()
+#     print("mono 16 conversion done successfully")
+#     return wav_bytes, 16000
+
+
+# ------------------------------------------------------------------
+# 2️⃣ Telugu STT (Speech-to-Text)
+# ------------------------------------------------------------------
+# def transcribe_telugu_audio(audio_bytes: bytes) -> tuple[str, float]:
+#     print("i am inside the stt (telugu to telugu)")
+#     wav_bytes, sample_rate = convert_to_mono16_wav_bytes(audio_bytes)
+#     print("mono 16 conversion done successfully and fetched")
+#     client = speech.SpeechClient()
+#     print("clinet called successfully")
+#     audio = speech.RecognitionAudio(content=wav_bytes)
+#     print("audio created successfully")
+#     config = speech.RecognitionConfig(
+#         encoding=speech.RecognitionConfig.AudioEncoding.LINEAR16,
+#         sample_rate_hertz=sample_rate,
+#         language_code="te-IN",
+#         enable_automatic_punctuation=True,
+#     )
+
+#     print("\n🔊 Transcribing Telugu audio...")
+#     start_time = time.time()
+#     response = client.recognize(config=config, audio=audio)
+
+#     telugu_text = " ".join(
+#         [result.alternatives[0].transcript for result in response.results]
+#     )
+#     stt_time = time.time() - start_time
+#     print(f"✅ Telugu STT completed in {stt_time:.2f} seconds")
+
+#     return telugu_text.strip(), stt_time
+
+
+# ------------------------------------------------------------------
+# 3️⃣ Telugu → English Translation
+# ------------------------------------------------------------------
+# def translate_to_english(te_text: str) -> tuple[str, float]:
+#     translate_client = translate.Client()
+#     print("\n🌐 Translating to English...")
+#     start_time = time.time()
+
+#     result = translate_client.translate(te_text, target_language="en")
+#     english_text = result["translatedText"]
+
+#     translation_time = time.time() - start_time
+#     print(f"✅ Translation completed in {translation_time:.2f} seconds")
+# manoj
+#     return english_text, translation_time
+
+
+@app.post("/chat_stream")
+async def chat_stream(file: UploadFile = File(...)):
+    start_time = time.time()
+    audio_bytes = await file.read()
+    print("audio file read")
+
+    transcription = client.audio.transcriptions.create(
+            model="gpt-4o-transcribe",  # or "gpt-4o-mini-transcribe"
+            file=(file.filename, audio_bytes)  # important: (filename, bytes)
+        )
+
+    telugu_text = transcription.text
+    print(f"the text is : {telugu_text}")
+    print(f"tts time : {time.time()-start_time}")
+    start_time = time.time()
+    translation = client.responses.create(
+        model="gpt-4o-mini",
+        temperature = 0,
+        top_p = 0,
+        input=f'''Translate the following Telugu text into English:
+        {telugu_text}
+        Give only the english translation, these are most probably queries from the user''')
+
+    english_text = translation.output[0].content[0].text
+    print(f"translation time {time.time() - start_time}")
+    print(f"the english text is {english_text}")
+
+    return StreamingResponse(gpt_tts_stream(english_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, medical assistant specializing in orthopedic surgery, human-like voice assistant built by Facile AI Solutions
+        You assist customers specifically with knee replacement surgery queries and you are the assistant of Dr.Sandeep, 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. Respond in **Telugu*.
+
+        2. *General conversation*: Engage in greetings and casual conversation. If the user mentions their name, greet them personally using their name, in Telugu.
+
+        3. *Technical/medical queries*:
+        Answer in *Telugu* based on the context or chat history.
+
+        - If the question is *relevant to knee replacement surgery and the answer is in the context or chat history, provide the answer in **Telugu*.
+        - If the question is *relevant but not present in the context*, respond: "దయచేసి డాక్టర్ సందీప్ లేదా రిసెప్షన్ ను సంప్రదించండి."
+
+        - Translate medical and technical terms into simple, **understandable conversational Telugu** wherever possible.
+        - The output must be in Telugu script, but common English medical or technical terms (like knee, hip, surgery, replacement, physiotherapy, arthritis, etc.)
+          should be written phonetically in Telugu, not translated literally.
+
+          Example:
+          “knee replacement” → మోకాలు రీప్లేస్‌మెంట్
+          “hip replacement” → హిప్ రీప్లేస్‌మెంట్
+          “surgery” → సర్జరీ
+          “physiotherapy” → ఫిజియోథెరపీ
+          Ensure the language sounds simple, natural, and conversational for Telugu-speaking patients.
+
+        4. *Irrelevant queries*:
+        - If the question is completely unrelated to knee replacement surgery, politely decline in Telugu: "నేను కేవలం మోకాలు రీప్లేస్‌మెంట్ సర్జరీ సంబంధిత ప్రశ్నలకు సహాయం చేస్తాను."
+
+        5. *Drive conversation*:
+        - After answering the user’s question, suggest a follow-up question from the context that you can answer, in *Telugu*
+        - Make the follow-up natural and conversational. The follow up question must be relevant to the current question or response in *Telugu*
+        - Do not include redundant statements like “మీరు మరింత సమాచారం కావాలనుకుంటే…”, "మీరు మరేదైనా అడగాలనుకుంటున్నారా" in the follow up questions
+        - If the user responds with confirmation like “yes”, “okay” give the answer for the previous follow-up question from the context.
+        - If the user ends the conversation, do not ask or suggest any follow-up question.
+
+
+        6. *Readable voice output for gTTS*:
+        - Break sentences at natural punctuation: , . ? ! : ;
+        - Do not use #, **, or other markdown symbols.
+          Telugu Output Guidelines:
+            All numbers, decimals, and points must be fully spelled out in Telugu words.
+            Example: 2.5 lakh → రెండు లక్షల యాభై వేల రూపాయలు
+
+        7. *Concise and human-like*:
+        - Keep answers short, conversational, and natural in *Telugu*.
+        - 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*:
+        - ALL the below points must be in *Telugu*
+        - Over 5 years of experience in orthopedic and joint replacement surgery.
+        - 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 in *Telugu* 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."}

templates/index.html

@@ -0,0 +1,152 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <title>Ortho Buddy — Voice</title>
+  <style>
+    html,body { height:100%; margin:0; font-family: "Segoe UI", Roboto, Arial; background: radial-gradient(circle at 50% 10%, #5ca4b0, #062219); color:#bfe6c9; }
+    .container { width:360px; margin:40px auto; text-align:center; }
+    h1 { letter-spacing:4px; font-size:36px; color:#2de08b; text-shadow:0 6px 30px rgba(0,0,0,0.7); margin:20px 0; }
+    .subtitle { color:#d6f3de; margin-bottom:10px; font-size:24px; }
+    .robot { width:270px; height:270px; background: url('/static/robot.gif') center/contain no-repeat; margin: 40px auto; border-radius:8px; }
+    .control { margin-top:20px; }
+    .record-btn { width:50px; height:50px; border-radius:60px; border:none; background:linear-gradient(rgb(248, 245, 248), rgb(248, 245, 248)); box-shadow: 0 10px 30px rgba(0,0,0,0.6); color:white; font-size:18px; cursor:pointer; }
+    .record-btn.recording { background: linear-gradient(#ff6666, #cc2222); box-shadow: 0 10px 30px rgba(0,0,0,0.7); }
+    .heading {
+  text-align: center; 
+}
+    .reset-btn {
+    position: fixed;
+    top: 20px;
+    right: 20px;
+    padding: 10px 20px;
+    background: linear-gradient(#2de08b, #0a8f5c);
+    border: none;
+    border-radius: 6px;
+    font-size: 16px;
+    font-weight: bold;
+    color: #062219;
+    cursor: pointer;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.4);
+    z-index: 1000;
+    transition: background 0.3s ease;
+}
+    .reset-btn:hover {
+  background: linear-gradient(#1bc47a, #07734f);
+}
+  </style>
+    <h1 class = "heading">Summit Clinics</h1>
+</head>
+<body>
+  <div class="container">
+    
+    <div class="subtitle"><b>KAMMI</b></div>
+
+    <div class="robot" id="robotImg"></div>
+
+    <div class="control">
+      <button id="recBtn" class="record-btn">🎤</button>
+    </div>
+
+    <button id="resetBtn" class="reset-btn">New User</button>
+
+    <div class="text-stream" id="textStream"></div>
+
+    <!-- Hidden audio player for streamed voice -->
+    <audio id="player" controls autoplay hidden></audio>
+  </div>
+
+<script>
+let mediaRecorder;
+let audioChunks = [];
+let recBtn = document.getElementById("recBtn");
+let textStream = document.getElementById("textStream");
+let recording = false;
+let player = document.getElementById("player");
+document.getElementById("resetBtn").addEventListener("click", async () => {
+  try {
+    const response = await fetch("/reset_chat", {
+      method: "POST"
+    });
+    if (response.ok) {
+      showTempMessage("Please proceed.", "lightgreen");
+    } else {
+      const errorText = await response.text();
+      showTempMessage("Reset failed: " + errorText, "#ffb3b3");
+    }
+  } catch (error) {
+    showTempMessage("Reset error: " + error.message, "#ffb3b3");
+  }
+});
+// Utility function to show a message for 2 seconds
+function showTempMessage(msg, color) {
+  const msgDiv = document.createElement("div");
+  msgDiv.style.color = color;
+  msgDiv.textContent = msg;
+  textStream.appendChild(msgDiv);
+  setTimeout(() => {
+    msgDiv.remove();
+  }, 2000);
+}
+recBtn.addEventListener("click", async () => {
+  if (!recording) {
+    await startRecording();
+  } else {
+    stopRecordingAndSend();
+  }
+  recording = !recording;
+  recBtn.textContent = recording ? "Stop" : "🎤";
+  recBtn.classList.toggle("recording", recording);
+});
+async function startRecording() {
+  textStream.innerHTML = ""; // clear previous
+  audioChunks = [];
+  if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+    alert("Your browser does not support microphone capture.");
+    return;
+  }
+  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+  mediaRecorder = new MediaRecorder(stream);
+  mediaRecorder.ondataavailable = e => {
+    if (e.data && e.data.size > 0) audioChunks.push(e.data);
+  };
+  mediaRecorder.start();
+}
+function stopRecordingAndSend() {
+  if (!mediaRecorder) return;
+  mediaRecorder.stop();
+  mediaRecorder.onstop = async () => {
+    const audioBlob = new Blob(audioChunks, { type: 'audio/webm' });
+    const form = new FormData();
+    form.append("file", audioBlob, "recording.webm");
+    // fetch streaming audio directly
+    console.log("Sending audio to server...");
+    const resp = await fetch("/chat_stream", {
+      method: "POST",
+      body: form,
+    });
+    if (!resp.ok) {
+      const txt = await resp.text();
+      textStream.innerHTML += "<div style='color:#ffb3b3'>Server error: " + txt + "</div>";
+      return;
+    }
+    // create an object URL from streaming response
+    const mediaSource = new MediaSource();
+    player.src = URL.createObjectURL(mediaSource);
+    mediaSource.addEventListener('sourceopen', async () => {
+      const sourceBuffer = mediaSource.addSourceBuffer('audio/mpeg');
+      const reader = resp.body.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        sourceBuffer.appendBuffer(value);
+        await new Promise(resolve => sourceBuffer.addEventListener('updateend', resolve, { once: true }));
+      }
+      mediaSource.endOfStream();
+    });
+    player.play();
+  };
+}
+</script>
+</body>
+</html>