Update app.py

app.py

@@ -3,22 +3,30 @@ import os
 import json
 import logging
 import re
-from typing import Dict, Any
+from typing import Dict, Any, List
 from pathlib import Path
-from unstructured.partition.pdf import partition_pdf
 from flask import Flask, request, jsonify
 from flask_cors import CORS
 from dotenv import load_dotenv
-from flask import send_from_directory, abort
-from bloatectomy import bloatectomy
 from werkzeug.utils import secure_filename
 from langchain_groq import ChatGroq
-from typing_extensions import TypedDict, NotRequired
+from typing_extensions import TypedDict
+
+# --- Type Definitions for State Management ---
+class TaggedReply(TypedDict):
+    reply: str
+    tags: List[str]
+
+class AssistantState(TypedDict):
+    conversationSummary: str
+    lastUserMessage: str
+    language: str # New field to track the programming language
+    taggedReplies: List[TaggedReply] # New field for saving/bookmarking replies
 
 # --- Logging ---
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
-logger = logging.getLogger("patient-assistant")
-ALLOWED_EXTENSIONS = {"pdf"}
+logger = logging.getLogger("code-assistant")
+
 # --- Load environment ---
 load_dotenv()
 GROQ_API_KEY = os.getenv("GROQ_API_KEY")
@@ -28,98 +36,51 @@ if not GROQ_API_KEY:
 
 # --- Flask app setup ---
 BASE_DIR = Path(__file__).resolve().parent
-REPORTS_ROOT = Path(os.getenv("REPORTS_ROOT", str(BASE_DIR / "reports")))
 static_folder = BASE_DIR / "static"
 
 app = Flask(__name__, static_folder=str(static_folder), static_url_path="/static")
 CORS(app)
 
-# Ensure the reports directory exists
-os.makedirs(REPORTS_ROOT, exist_ok=True)
-
 # --- LLM setup ---
+# Using a model that's good for coding tasks
 llm = ChatGroq(
-    model=os.getenv("LLM_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct"),
-    temperature=0.0,
-    max_tokens=1024,
+    model=os.getenv("LLM_MODEL", "mixtral-8x7b-32768"), # Changed to a coding-friendly model
+    temperature=0.1, # Slightly less creative than general chat
+    max_tokens=2048, # Increased token limit for code
     api_key=GROQ_API_KEY,
 )
 
-def clean_notes_with_bloatectomy(text: str, style: str = "remov") -> str:
-    try:
-        b = bloatectomy(text, style=style, output="html")
-        tokens = getattr(b, "tokens", None)
-        if not tokens:
-            return text
-        return "\n".join(tokens)
-    except Exception:
-        logger.exception("Bloatectomy cleaning failed; returning original text")
-        return text
-
-PATIENT_ASSISTANT_PROMPT = """
-You are a helpful medical assistant acting as a doctor. You respond naturally to greetings and general medical questions without asking for patient ID unless the user requests information about prior medical records
+PROGRAMMING_ASSISTANT_PROMPT = """
+You are an expert programming assistant. Your role is to provide code suggestions, fix bugs, explain programming concepts, and offer contextual help based on the user's query and preferred programming language.
 
 Behavior rules (follow these strictly):
-- Do NOT ask for the patient ID at the start of every conversation. Only request the PID when the user's question explicitly requires accessing prior medical records (for example: "show my previous lab report", "what does my thyroid test from last month say", "what was my doctor's note for PID 12345", etc.).
-- When you do ask for a PID, be concise and ask only for the PID (e.g., "Please provide the patient ID (PID) to retrieve previous records."). Do not request name/DOB/other verification unless the user explicitly asks for an extra verification step.
-- If the user supplies a PID in their message (patterns like "pid 5678", "p5678", "patient id: 5678"), accept and use it — do not ask again.
-- Never ask for the PID if it is already known. If the user provides a different PID later, update it and proceed accordingly.
-- Avoid repeating unnecessary clarifying questions. If you previously asked for the PID and the user didn't provide it, ask once more succinctly and then offer to help with general guidance without records.
-- When analyzing medical reports, trust the patient ID from the folder or query context as the source of truth.
-- **If the report text mentions a different patient ID or name, do not refuse to answer but mention the discrepancy politely and proceed to answer based on the available data.**
-- **Always protect patient privacy and avoid sharing information from reports not matching the current PID unless explicitly requested and with a clear disclaimer.**
+- Contextual Help: Always aim to provide the most helpful, clear, and accurate information.
+- Code Suggestions: When suggesting code, always enclose it in appropriate markdown code blocks (e.g., ```python\n...\n```).
+- Error Explanation: When an error is provided, explain the root cause and provide a corrected code snippet if possible.
+- Conceptual Questions: For questions like "What is a loop?", provide a clear, concise explanation with a simple, illustrative code example in the user's current language (if known, otherwise Python/JavaScript).
+- Language Adaptation: Adjust your suggestions, code, and explanations to the programming language specified in the 'language' field of the 'AssistantState'. If 'language' is not set, ask the user what language they are working in.
 
 STRICT OUTPUT FORMAT (JSON ONLY):
 Return a single JSON object with the following keys:
 - assistant_reply: string  // a natural language reply to the user (short, helpful, always present)
-- patientDetails: object  // keys may include name, problem, pid (patient ID), city, contact (update if user shared info)
-- conversationSummary: string (optional)  // short summary of conversation + relevant patient docs
+- state_updates: object  // updates to the internal state, keys may include: language, conversationSummary
+- suggested_tags: array of strings // a list of 1-3 relevant tags for the assistant_reply (e.g., "Python", "Debugging", "Loop Concept")
 
 Rules:
 - ALWAYS include `assistant_reply` as a non-empty string.
 - Do NOT produce any text outside the JSON object.
-- Be concise in `assistant_reply`. If you need more details, ask a targeted follow-up question.
-- Do not make up information that is not present in the provided medical reports or conversation history.
+- Be concise in `assistant_reply`, but ensure the information is complete.
+- Do not make up information.
 """
 
-PID_PATTERN = re.compile(r"(?:\bpid\b|\bpatient\s*id\b|\bp\b)\s*[:#\-]?\s*(p?\d+)", re.IGNORECASE)
-DIGIT_PATTERN = re.compile(r"\b(p?\d{3,})\b")
-
-RECORD_KEYWORDS = [
-    "report", "lab", "result", "results", "previous", "history", "record", "records",
-    "test", "tests", "scan", "imaging", "radiology", "thyroid", "tsh", "t3", "t4",
-    "prescription", "doctor", "referral", "visit", "consultation",
-]
-
-def extract_pid_from_text(text: str) -> str | None:
-    if not text:
-        return None
-    m = PID_PATTERN.search(text)
-    if m:
-        return m.group(1).lstrip('pP')
-    if any(k in text.lower() for k in RECORD_KEYWORDS):
-        m2 = DIGIT_PATTERN.search(text)
-        if m2:
-            return m2.group(1).lstrip('pP')
-    return None
-
-def needs_pid_for_query(text: str) -> bool:
-    if not text:
-        return False
-    lower = text.lower()
-    phrases = ["previous report", "previous lab", "my report", "my records", "past report", "last report", "previous test", "previous results"]
-    if any(p in lower for p in phrases):
-        return True
-    if any(k in lower for k in RECORD_KEYWORDS):
-        return True
-    return False
-
 def extract_json_from_llm_response(raw_response: str) -> dict:
+    # Helper function remains largely the same, adapted for new keys
     default = {
         "assistant_reply": "I'm sorry — I couldn't understand that. Could you please rephrase?",
-        "patientDetails": {},
-        "conversationSummary": "",
+        "state_updates": {},
+        "suggested_tags": [],
     }
+    # ... [JSON parsing logic remains similar] ...
     if not raw_response or not isinstance(raw_response, str):
         return default
     m = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", raw_response)
@@ -139,62 +100,26 @@ def extract_json_from_llm_response(raw_response: str) -> dict:
     except Exception as e:
         logger.warning("Failed to parse JSON from LLM output: %s", e)
         return default
+    
+    # Validation for new keys
     if isinstance(parsed, dict) and "assistant_reply" in parsed and isinstance(parsed["assistant_reply"], str) and parsed["assistant_reply"].strip():
-        parsed.setdefault("patientDetails", {})
-        parsed.setdefault("conversationSummary", "")
+        parsed.setdefault("state_updates", {})
+        parsed.setdefault("suggested_tags", [])
         return parsed
     else:
         logger.warning("Parsed JSON missing 'assistant_reply' or invalid format. Returning default.")
         return default
 
-def extract_details_from_user_message(user_message: str) -> dict:
-    """
-    Use the LLM to extract patient details (name, contact, city, problem) from the user's last message.
-    Returns a dict with any found fields.
-    """
-    extraction_prompt = f"""
-Extract any patient details from the following user message. Return a JSON object with keys name, contact, city, problem.
-If a field is not present, omit it.
-
-User message:
-\"\"\"{user_message}\"\"\"
-"""
-    messages = [
-        {"role": "system", "content": "You are a helpful assistant that extracts patient details from user messages."},
-        {"role": "user", "content": extraction_prompt}
-    ]
-    try:
-        response = llm.invoke(messages)
-        content = response.content if hasattr(response, "content") else str(response)
-        extracted = extract_json_from_llm_response(content)
-        return extracted.get("patientDetails", extracted)  # support both keys
-    except Exception as e:
-        logger.warning(f"Detail extraction failed: {e}")
-        return {}
-
 # --- Flask routes ---
 @app.route("/", methods=["GET"])
 def serve_frontend():
     try:
-        return app.send_static_file("frontend.html")
+        # Assuming you will update frontend.html for the new assistant
+        return app.send_static_file("frontend.html") 
     except Exception:
         return "<h3>frontend.html not found in static/ — please add your frontend.html there.</h3>", 404
 
-@app.route("/upload_report", methods=["POST"])
-def upload_report():
-    if 'report' not in request.files:
-        return jsonify({"error": "No file part in the request"}), 400
-    file = request.files['report']
-    patient_id = request.form.get("patient_id")
-    if file.filename == '' or not patient_id:
-        return jsonify({"error": "No selected file or patient ID"}), 400
-    if file:
-        filename = secure_filename(file.filename)
-        patient_folder = REPORTS_ROOT / f"{patient_id}"
-        os.makedirs(patient_folder, exist_ok=True)
-        file_path = patient_folder / filename
-        file.save(file_path)
-        return jsonify({"message": f"File '{filename}' uploaded successfully for patient ID '{patient_id}'."}), 200
+# UPLOAD routes are removed as they are no longer needed.
 
 @app.route("/chat", methods=["POST"])
 def chat():
@@ -202,291 +127,177 @@ def chat():
     if not isinstance(data, dict):
         return jsonify({"error": "invalid request body"}), 400
 
-    chat_history = data.get("chat_history") or []
-    patient_state = data.get("patient_state") or {}
-    patient_details = patient_state.get("patientDetails", {})
-    patient_id = patient_details.get("pid")
-
-    state = patient_state.copy()
-    state.setdefault("asked_for_pid", False)
-    state.setdefault("conversationSummary", state.get("conversationSummary", ""))
-    state["lastUserMessage"] = ""
-    if chat_history:
-        for msg in reversed(chat_history):
-            if msg.get("role") == "user" and msg.get("content"):
-                state["lastUserMessage"] = msg["content"]
-                break
-
-    inferred_pid = extract_pid_from_text(state.get("lastUserMessage", "") or "")
-    patient_id_str = str(patient_id) if patient_id is not None else ""
-    if (not patient_id_str or patient_id_str.strip() == "") and inferred_pid:
-        logger.info("Inferred PID from user message: %s", inferred_pid)
-        state.setdefault("patientDetails", {})["pid"] = inferred_pid
-        patient_id = inferred_pid
-
-    combined_text_parts = []
-
-    wants_records = needs_pid_for_query(state.get("lastUserMessage", "") or "")
-
-    # If user wants records but no PID yet, ask for PID (same behavior as before)
-    if wants_records and (not patient_id or patient_id_str.strip() == ""):
-        if not state.get("asked_for_pid", False):
-            assistant_reply = "Please provide the patient ID (PID) to retrieve previous records."
-            state["asked_for_pid"] = True
-            response_payload = {
-                "assistant_reply": assistant_reply,
-                "updated_state": state,
-            }
-            return jsonify(response_payload)
-        else:
-            assistant_reply = (
-                "I still need your Patient ID (PID) to access your records. "
-                "If you prefer, I can help with general medical questions instead."
-            )
-            response_payload = {
-                "assistant_reply": assistant_reply,
-                "updated_state": state,
-            }
-            return jsonify(response_payload)
-
-    # If we have a PID, check whether any allowed files exist for that PID.
-    has_allowed_files = False
-    if patient_id and str(patient_id).strip() != "":
-        patient_folder = REPORTS_ROOT / f"{patient_id}"
-        if patient_folder.exists() and patient_folder.is_dir():
-            for f in patient_folder.iterdir():
-                if f.is_file():
-                    ext = f.suffix.lower().lstrip(".")
-                    if ext in ALLOWED_EXTENSIONS:
-                        has_allowed_files = True
-                        break
-
-        # IMPORTANT: do NOT short-circuit here.
-        # If the user explicitly asked for previous records (wants_records == True)
-        # and we have no files, we will tell the LLM that there are no uploaded records
-        # via the SYSTEM_HINT (so LLM can respond appropriately). We DO NOT return early,
-        # and we DO NOT add any extra JSON fields to the response.
-        if has_allowed_files:
-            # read files and build combined_text_parts (existing behavior)
-            for fname in sorted(os.listdir(patient_folder)):
-                file_path = patient_folder / fname
-                page_text = ""
-                if partition_pdf is not None and str(file_path).lower().endswith('.pdf'):
-                    try:
-                        elements = partition_pdf(filename=str(file_path))
-                        page_text = "\n".join([el.text for el in elements if hasattr(el, 'text') and el.text])
-                    except Exception:
-                        logger.exception("Failed to parse PDF %s", file_path)
-                else:
-                    try:
-                        page_text = file_path.read_text(encoding='utf-8', errors='ignore')
-                    except Exception:
-                        page_text = ""
-
-                if page_text:
-                    cleaned = clean_notes_with_bloatectomy(page_text, style="remov")
-                    if cleaned:
-                        combined_text_parts.append(cleaned)
-        else:
-            # no files: do not modify state or return. We'll include a hint for the LLM below
-            logger.info("No uploaded files found for PID %s. Will inform LLM only if user asked for records.", patient_id)
-
-    # Build conversationSummary from any docs we read (unchanged)
-    base_summary = state.get("conversationSummary", "") or ""
-    docs_summary = "\n\n".join(combined_text_parts)
-    if docs_summary:
-        state["conversationSummary"] = (base_summary + "\n\n" + docs_summary).strip()
-    else:
-        state["conversationSummary"] = base_summary
-
-    # Prepare the action hint. If user asked for records but there are no uploaded files,
-    # explicitly tell the LLM so it can respond like "No records available for PID X".
-    if patient_id and str(patient_id).strip() != "":
-        if wants_records and not has_allowed_files:
-            action_hint = (
-                f"User asked about prior records. NOTE: there are NO uploaded medical records for patient ID {patient_id}."
-            )
-        else:
-            action_hint = f"Use the patient ID {patient_id} to retrieve and summarize any relevant reports."
+    chat_history: List[Dict[str, str]] = data.get("chat_history") or []
+    # Using 'assistant_state' to clearly separate from old patient_state
+    assistant_state: AssistantState = data.get("assistant_state") or {}
+
+    # Initialize/Clean up state
+    state: AssistantState = {
+        "conversationSummary": assistant_state.get("conversationSummary", ""),
+        "lastUserMessage": "",
+        "language": assistant_state.get("language", "Python"), # Default to Python
+        "taggedReplies": assistant_state.get("taggedReplies", []),
+    }
+    
+    # Find the last user message
+    for msg in reversed(chat_history):
+        if msg.get("role") == "user" and msg.get("content"):
+            state["lastUserMessage"] = msg["content"]
+            break
+
+    # --- Language Detection (Simple check for common programming languages) ---
+    last_msg_lower = state["lastUserMessage"].lower()
+    known_languages = ["python", "javascript", "java", "c++", "c#", "go", "ruby", "php", "typescript", "swift"]
+    
+    # A simple regex to detect a language mention in the last message
+    lang_match = re.search(r'\b(in|using|for)\s+(' + '|'.join(known_languages) + r')\b', last_msg_lower)
+    if lang_match:
+        detected_lang = lang_match.group(2).capitalize()
+        if detected_lang != state["language"]:
+            logger.info("Detected new language: %s", detected_lang)
+            state["language"] = detected_lang
+    
+    # --- LLM Prompt Construction ---
+    action_hint = ""
+    if state["language"]:
+        action_hint = f"Focus your answer on the {state['language']} programming language. If the user asks a conceptual question, use {state['language']} for examples."
     else:
-        action_hint = "No PID provided and the user's request does not need prior records. Provide helpful, general medical guidance and offer to retrieve records if the user later supplies a PID."
+        action_hint = "The current language is unknown. Please ask the user to specify the programming language they are working in."
 
     user_prompt = f"""
-Current patientDetails: {json.dumps(state.get("patientDetails", {}))}
-Current conversationSummary: {state.get("conversationSummary", "")[:4000]}
-Last user message: {state.get("lastUserMessage", "")}
+Current State: {json.dumps({"language": state["language"], "summary": state["conversationSummary"]})}
+Last user message: {state["lastUserMessage"]}
 
 SYSTEM_HINT: {action_hint}
 
-Return ONLY valid JSON with keys: assistant_reply, patientDetails, conversationSummary.
+Return ONLY valid JSON with keys: assistant_reply, state_updates, suggested_tags.
 """
 
     messages = [
-        {"role": "system", "content": PATIENT_ASSISTANT_PROMPT},
+        {"role": "system", "content": PROGRAMMING_ASSISTANT_PROMPT},
         {"role": "user", "content": user_prompt}
     ]
 
     try:
-        logger.info("Invoking LLM with prepared state and prompt...")
+        logger.info("Invoking LLM for code assistant...")
         llm_response = llm.invoke(messages)
-        raw_response = ""
-        if hasattr(llm_response, "content"):
-            raw_response = llm_response.content
-        else:
-            raw_response = str(llm_response)
+        raw_response = llm_response.content if hasattr(llm_response, "content") else str(llm_response)
 
-        logger.info(f"Raw LLM response: {raw_response}")
+        logger.info(f"Raw LLM response: {raw_response[:200]}...")
         parsed_result = extract_json_from_llm_response(raw_response)
 
     except Exception as e:
         logger.exception("LLM invocation failed")
         return jsonify({"error": "LLM invocation failed", "detail": str(e)}), 500
 
-    updated_state = parsed_result or {}
-
-    # Merge patientDetails back into state (but avoid overwriting asked_for_pid)
-    state.setdefault("patientDetails", {}).update(updated_state.get("patientDetails", {}))
-    state["conversationSummary"] = updated_state.get("conversationSummary", state.get("conversationSummary", ""))
-
-    # --- New: Extract details from last user message to update patientDetails ---
-    REQUIRED_DETAILS = ["name", "contact", "city", "problem"]
-    booking_intent_keywords = ["book appointment", "schedule appointment", "make appointment", "appointment"]
-
-    last_msg_lower = state.get("lastUserMessage", "").lower()
-    conversation_summary_lower = state.get("conversationSummary", "").lower()
-
-    wants_to_book = any(kw in last_msg_lower for kw in booking_intent_keywords) or \
-                    any(kw in conversation_summary_lower for kw in booking_intent_keywords)
-
-    if wants_to_book:
-        # Extract details from last user message
-        extracted_details = extract_details_from_user_message(state.get("lastUserMessage", ""))
-        patient_details = state.setdefault("patientDetails", {})
-        # Update patientDetails with any newly extracted info
-        for key in REQUIRED_DETAILS:
-            if key in extracted_details and extracted_details[key]:
-                patient_details[key] = extracted_details[key]
-
-        missing_fields = [field for field in REQUIRED_DETAILS if not patient_details.get(field)]
-        if missing_fields:
-            missing_field = missing_fields[0]
-            field_prompts = {
-                "name": "Could you please provide your full name?",
-                "contact": "May I have your contact number?",
-                "city": "What city are you located in?",
-                "problem": "Please briefly describe your medical problem or reason for the appointment.",
-            }
-            assistant_reply = field_prompts.get(missing_field, f"Please provide your {missing_field}.")
-            response_payload = {
-                "assistant_reply": assistant_reply,
-                "updated_state": state,
-            }
-            return jsonify(response_payload)
-
-    assistant_reply = updated_state.get("assistant_reply")
+    # --- State Update from LLM ---
+    updated_state_from_llm = parsed_result.get("state_updates", {})
+    
+    # Update state fields that the LLM is allowed to modify
+    if 'conversationSummary' in updated_state_from_llm:
+        state["conversationSummary"] = updated_state_from_llm["conversationSummary"]
+    if 'language' in updated_state_from_llm:
+        state["language"] = updated_state_from_llm["language"]
+
+    assistant_reply = parsed_result.get("assistant_reply")
     if not assistant_reply or not isinstance(assistant_reply, str) or not assistant_reply.strip():
-        assistant_reply = "I'm here to help — could you tell me more about your symptoms or provide a Patient ID (PID) if you want me to fetch past reports?"
+        assistant_reply = "I'm here to help with your code! What programming language are you using?"
 
+    # --- Final Response Payload ---
     response_payload = {
         "assistant_reply": assistant_reply,
         "updated_state": state,
+        "suggested_tags": parsed_result.get("suggested_tags", []), # Pass tags to frontend
     }
 
     return jsonify(response_payload)
 
-@app.route("/upload_reports", methods=["POST"])
-def upload_reports():
-    try:
-        patient_id = request.form.get("patient_id") or request.args.get("patient_id")
-        if not patient_id:
-            return jsonify({"error": "patient_id form field required"}), 400
-
-        uploaded_files = request.files.getlist("files")
-        if not uploaded_files:
-            single = request.files.get("file")
-            if single:
-                uploaded_files = [single]
-
-        if not uploaded_files:
-            return jsonify({"error": "no files uploaded (use form field 'files')"}), 400
-
-        patient_folder = REPORTS_ROOT / str(patient_id)
-        patient_folder.mkdir(parents=True, exist_ok=True)
-
-        saved = []
-        skipped = []
-
-        for file_storage in uploaded_files:
-            orig_name = getattr(file_storage, "filename", "") or ""
-            filename = secure_filename(orig_name)
-            if not filename:
-                skipped.append({"filename": orig_name, "reason": "invalid filename"})
-                continue
-
-            ext = filename.rsplit(".", 1)[1].lower() if "." in filename else ""
-            if ext not in ALLOWED_EXTENSIONS:
-                skipped.append({"filename": filename, "reason": f"extension '{ext}' not allowed"})
-                continue
-
-            dest = patient_folder / filename
-            if dest.exists():
-                base, dot, extension = filename.rpartition(".")
-                base = base or filename
-                i = 1
-                while True:
-                    candidate = f"{base}__{i}.{extension}" if extension else f"{base}__{i}"
-                    dest = patient_folder / candidate
-                    if not dest.exists():
-                        filename = candidate
-                        break
-                    i += 1
-
-            try:
-                file_storage.save(str(dest))
-                saved.append(filename)
-            except Exception as e:
-                logger.exception("Failed to save uploaded file %s: %s", filename, e)
-                skipped.append({"filename": filename, "reason": f"save failed: {e}"})
-
-        return jsonify({
-            "patient_id": str(patient_id),
-            "saved": saved,
-            "skipped": skipped,
-            "patient_folder": str(patient_folder)
-        }), 200
-
-    except Exception as exc:
-        logger.exception("Upload failed: %s", exc)
-        return jsonify({"error": "upload failed", "detail": str(exc)}), 500
-
-@app.route("/<patient_id>/<filename>")
-def serve_report(patient_id, filename):
-    """
-    Serve a specific uploaded PDF (or other allowed file) for a patient.
-    URL format: /<patient_id>/<filename>
-    Example:   /p14562/report1.pdf
-    """
-    try:
-        patient_folder = REPORTS_ROOT / str(patient_id)
-
-        if not patient_folder.exists():
-            abort(404, description=f"Patient folder not found: {patient_id}")
+# --- New Route for Tagging/Bookmarking Replies ---
+@app.route("/tag_reply", methods=["POST"])
+def tag_reply():
+    data = request.get_json(force=True)
+    if not isinstance(data, dict):
+        return jsonify({"error": "invalid request body"}), 400
 
-        # security check: only allow files with allowed extensions
-        ext = filename.rsplit(".", 1)[-1].lower() if "." in filename else ""
-        if ext not in ALLOWED_EXTENSIONS:
-            abort(403, description=f"Extension '{ext}' not allowed")
+    reply_content = data.get("reply")
+    tags = data.get("tags")
+    assistant_state: AssistantState = data.get("assistant_state") or {}
+
+    if not reply_content or not tags:
+        return jsonify({"error": "Missing 'reply' or 'tags' in request"}), 400
+    
+    # Ensure tags is a list of strings
+    tags = [str(t).strip() for t in tags if str(t).strip()]
+    if not tags:
+        return jsonify({"error": "Tags list cannot be empty"}), 400
+
+    # Clean up state dictionary
+    state: AssistantState = {
+        "conversationSummary": assistant_state.get("conversationSummary", ""),
+        "lastUserMessage": "",
+        "language": assistant_state.get("language", "Python"),
+        "taggedReplies": assistant_state.get("taggedReplies", []),
+    }
 
-        return send_from_directory(
-            directory=str(patient_folder),
-            path=filename,
-            as_attachment=False  # set True if you want download instead of inline view
-        )
+    new_tagged_reply: TaggedReply = {
+        "reply": reply_content,
+        "tags": tags,
+    }
 
-    except Exception as e:
-        logger.exception("Failed to serve file %s/%s: %s", patient_id, filename, e)
-        abort(500, description=f"Failed to serve file: {e}")
+    # Add the new tagged reply
+    state["taggedReplies"].append(new_tagged_reply)
+    
+    logger.info("Reply tagged with: %s", tags)
 
+    return jsonify({
+        "message": "Reply saved and tagged successfully.",
+        "updated_state": state,
+    }), 200
+
+# --- Filtering/Search Route for Bookmarked Replies ---
+@app.route("/search_tags", methods=["GET"])
+def search_tags():
+    tag_query = request.args.get("tag")
+    # Using POST for /chat, so we'll pass state in the body
+    # For a simple GET search, we'd need the state to be sent here, 
+    # but for simplicity, let's assume the state is passed in a POST body
+    # or fetched/maintained on the frontend and this route is just for logic.
+    
+    # Assuming the frontend sends the current state via a POST request for search
+    if request.method == "GET":
+        return jsonify({"error": "Please use POST and include 'assistant_state' in the body for tag search."}), 405
+    
+    # If using POST, you'd process request.get_json() here to get assistant_state
+    # For now, let's stick to the simpler GET and assume the frontend handles the state.
+    # To demonstrate the filtering logic:
+    
+    # --- DUMMY STATE FOR DEMO ---
+    dummy_state: AssistantState = {
+        "conversationSummary": "",
+        "lastUserMessage": "",
+        "language": "Python",
+        "taggedReplies": [
+            {"reply": "A Python loop example.", "tags": ["Python", "Loop Concept"]},
+            {"reply": "Fix for 'undefined' error in JS.", "tags": ["JavaScript", "Debugging"]},
+            {"reply": "Explanation of Polymorphism.", "tags": ["Java", "OOP"]},
+        ],
+    }
+    
+    if not tag_query:
+        # Return all tagged replies if no query
+        return jsonify({"tag_query": "", "results": dummy_state["taggedReplies"]}), 200
+
+    tag_query_lower = tag_query.lower()
+    
+    filtered_results = [
+        reply for reply in dummy_state["taggedReplies"] 
+        if any(tag_query_lower in tag.lower() for tag in reply["tags"])
+    ]
+    
+    return jsonify({
+        "tag_query": tag_query,
+        "results": filtered_results
+    }), 200
 
 @app.route("/ping", methods=["GET"])
 def ping():
@@ -494,4 +305,4 @@ def ping():
 
 if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))
-    app.run(host="0.0.0.0", port=port, debug=True)
+    app.run(host="0.0.0.0", port=port, debug=True)