Merge branch 'main' of hf.co:spaces/MedAI-COS30018/MedicalDiagnosisSystem into hf_main

.dockerignore

@@ -1,7 +1,14 @@
 .git
 .gitignore
+
 .env
 .venv
+
 __pycache__
 *.pyc
+
+*.md
+LICENSE
+
+tests
 key

schemas/account_validator.json

@@ -6,8 +6,7 @@
 			"name",
 			"role",
 			"created_at",
-			"updated_at",
-			"last_seen"
+			"updated_at"
 		],
 		"properties": {
 			"name": {

src/api/routes/emr.py

@@ -3,10 +3,13 @@
 from datetime import datetime, timezone
 from typing import List, Optional
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, UploadFile, File, Form
+from fastapi.responses import JSONResponse
 
-from src.models.emr import EMRResponse, EMRSearchRequest, EMRUpdateRequest
+from src.models.emr import EMRResponse, EMRSearchRequest, EMRUpdateRequest, ExtractedData
 from src.services.service import EMRService
+from src.services.extractor import EMRExtractor
+from src.data.emr_update import EMRUpdateService
 from src.core.state import AppState, get_state
 from src.utils.logger import logger
 
@@ -17,7 +20,7 @@ router = APIRouter(prefix="/emr", tags=["EMR"])
 async def check_emr_exists(message_id: str):
     """Check if EMR extraction has already been done for a message."""
     try:
-        from data.repositories.emr import check_emr_exists
+        from src.data.repositories.emr import check_emr_exists
         exists = check_emr_exists(message_id)
         return {
             "message_id": message_id,
@@ -88,11 +91,11 @@ async def extract_emr_from_message(
             patient = get_patient_by_id(patient_id)
             if patient:
                 patient_context = {
-                    "name": patient.get("name"),
-                    "age": patient.get("age"),
-                    "sex": patient.get("sex"),
-                    "medications": patient.get("medications", []),
-                    "past_assessment_summary": patient.get("past_assessment_summary")
+                    "name": patient.name,
+                    "age": patient.age,
+                    "sex": patient.sex,
+                    "medications": patient.medications or [],
+                    "past_assessment_summary": patient.past_assessment_summary
                 }
         except Exception as e:
             logger().warning(f"Could not fetch patient context: {e}")
@@ -278,11 +281,11 @@ async def bulk_extract_emr(
                     patient = get_patient_by_id(extraction['patient_id'])
                     if patient:
                         patient_context = {
-                            "name": patient.get("name"),
-                            "age": patient.get("age"),
-                            "sex": patient.get("sex"),
-                            "medications": patient.get("medications", []),
-                            "past_assessment_summary": patient.get("past_assessment_summary")
+                            "name": patient.name,
+                            "age": patient.age,
+                            "sex": patient.sex,
+                            "medications": patient.medications or [],
+                            "past_assessment_summary": patient.past_assessment_summary
                         }
                 except Exception as e:
                     logger().warning(f"Could not fetch patient context for extraction {i}: {e}")
@@ -324,3 +327,300 @@ async def bulk_extract_emr(
     except Exception as e:
         logger().error(f"Error in bulk EMR extraction: {e}")
         raise HTTPException(status_code=500, detail=str(e))
+
+
+def get_emr_extractor(state: AppState = Depends(get_state)) -> EMRExtractor:
+    """Get EMR extractor instance."""
+    return EMRExtractor(state.gemini_rotator)
+
+
+def get_emr_update_service() -> EMRUpdateService:
+    """Get EMR update service instance."""
+    return EMRUpdateService()
+
+
+@router.post("/upload-document", response_model=dict)
+async def upload_and_analyze_document(
+    patient_id: str = Form(...),
+    file: UploadFile = File(...),
+    emr_extractor: EMRExtractor = Depends(get_emr_extractor),
+    emr_update_service: EMRUpdateService = Depends(get_emr_update_service)
+):
+    """Upload and analyze a medical document to extract EMR data."""
+    try:
+        # Validate patient ID
+        if not patient_id or not patient_id.strip():
+            raise HTTPException(status_code=400, detail="Patient ID is required")
+
+        # Validate file
+        if not file or not file.filename:
+            raise HTTPException(status_code=400, detail="No file provided")
+
+        # Check file size (limit to 10MB)
+        file_content = await file.read()
+        if len(file_content) > 10 * 1024 * 1024:  # 10MB
+            raise HTTPException(status_code=400, detail="File size exceeds 10MB limit")
+
+        # Check file type
+        allowed_extensions = {'.pdf', '.doc', '.docx', '.jpg', '.jpeg', '.png', '.tiff'}
+        file_extension = '.' + file.filename.split('.')[-1].lower() if '.' in file.filename else ''
+        if file_extension not in allowed_extensions:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Unsupported file type. Allowed types: {', '.join(allowed_extensions)}"
+            )
+
+        logger().info(f"Document upload requested for patient {patient_id}, file: {file.filename}")
+
+        # Get patient context if available
+        patient_context = None
+        try:
+            from src.data.repositories.patient import get_patient_by_id
+            patient = get_patient_by_id(patient_id)
+            if patient:
+                patient_context = {
+                    "name": patient.name,
+                    "age": patient.age,
+                    "sex": patient.sex,
+                    "medications": patient.medications or [],
+                    "past_assessment_summary": patient.past_assessment_summary
+                }
+        except Exception as e:
+            logger().warning(f"Could not fetch patient context: {e}")
+
+        # Analyze the document
+        extracted_data, confidence_score = await emr_extractor.analyze_document(
+            file_content=file_content,
+            filename=file.filename,
+            patient_context=patient_context
+        )
+
+        # Save to database
+        emr_id = await emr_update_service.save_document_analysis(
+            patient_id=patient_id,
+            filename=file.filename,
+            file_content=file_content,
+            extracted_data=extracted_data,
+            confidence_score=confidence_score
+        )
+
+        return {
+            "emr_id": emr_id,
+            "filename": file.filename,
+            "confidence_score": confidence_score,
+            "extracted_data": {
+                "overview": extracted_data.notes.split("Document Overview: ")[-1] if "Document Overview:" in extracted_data.notes else "",
+                "diagnosis": extracted_data.diagnosis or [],
+                "symptoms": extracted_data.symptoms or [],
+                "medications": [
+                    {
+                        "name": med.name,
+                        "dosage": med.dosage,
+                        "frequency": med.frequency,
+                        "duration": med.duration
+                    }
+                    for med in extracted_data.medications or []
+                ],
+                "vital_signs": {
+                    "blood_pressure": extracted_data.vital_signs.blood_pressure if extracted_data.vital_signs else None,
+                    "heart_rate": extracted_data.vital_signs.heart_rate if extracted_data.vital_signs else None,
+                    "temperature": extracted_data.vital_signs.temperature if extracted_data.vital_signs else None,
+                    "respiratory_rate": extracted_data.vital_signs.respiratory_rate if extracted_data.vital_signs else None,
+                    "oxygen_saturation": extracted_data.vital_signs.oxygen_saturation if extracted_data.vital_signs else None
+                } if extracted_data.vital_signs else None,
+                "lab_results": [
+                    {
+                        "test_name": lab.test_name,
+                        "value": lab.value,
+                        "unit": lab.unit,
+                        "reference_range": lab.reference_range
+                    }
+                    for lab in extracted_data.lab_results or []
+                ],
+                "procedures": extracted_data.procedures or [],
+                "notes": extracted_data.notes or ""
+            },
+            "message": "Document analyzed and EMR data extracted successfully"
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger().error(f"Error in document upload and analysis: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/preview-document", response_model=dict)
+async def preview_document_analysis(
+    patient_id: str = Form(...),
+    file: UploadFile = File(...),
+    emr_extractor: EMRExtractor = Depends(get_emr_extractor)
+):
+    """Upload and analyze a medical document to preview extracted data before saving."""
+    try:
+        # Validate patient ID
+        if not patient_id or not patient_id.strip():
+            raise HTTPException(status_code=400, detail="Patient ID is required")
+
+        # Validate file
+        if not file or not file.filename:
+            raise HTTPException(status_code=400, detail="No file provided")
+
+        # Check file size (limit to 10MB)
+        file_content = await file.read()
+        if len(file_content) > 10 * 1024 * 1024:  # 10MB
+            raise HTTPException(status_code=400, detail="File size exceeds 10MB limit")
+
+        # Check file type
+        allowed_extensions = {'.pdf', '.doc', '.docx', '.jpg', '.jpeg', '.png', '.tiff'}
+        file_extension = '.' + file.filename.split('.')[-1].lower() if '.' in file.filename else ''
+        if file_extension not in allowed_extensions:
+            raise HTTPException(
+                status_code=400, 
+                detail=f"Unsupported file type. Allowed types: {', '.join(allowed_extensions)}"
+            )
+
+        logger().info(f"Document preview requested for patient {patient_id}, file: {file.filename}")
+
+        # Get patient context if available
+        patient_context = None
+        try:
+            from src.data.repositories.patient import get_patient_by_id
+            patient = get_patient_by_id(patient_id)
+            if patient:
+                patient_context = {
+                    "name": patient.name,
+                    "age": patient.age,
+                    "sex": patient.sex,
+                    "medications": patient.medications or [],
+                    "past_assessment_summary": patient.past_assessment_summary
+                }
+        except Exception as e:
+            logger().warning(f"Could not fetch patient context: {e}")
+
+        # Analyze the document
+        extracted_data, confidence_score = await emr_extractor.analyze_document(
+            file_content=file_content,
+            filename=file.filename,
+            patient_context=patient_context
+        )
+
+        return {
+            "filename": file.filename,
+            "confidence_score": confidence_score,
+            "extracted_data": {
+                "overview": extracted_data.notes.split("Document Overview: ")[-1] if "Document Overview:" in extracted_data.notes else "",
+                "diagnosis": extracted_data.diagnosis or [],
+                "symptoms": extracted_data.symptoms or [],
+                "medications": [
+                    {
+                        "name": med.name,
+                        "dosage": med.dosage,
+                        "frequency": med.frequency,
+                        "duration": med.duration
+                    }
+                    for med in extracted_data.medications or []
+                ],
+                "vital_signs": {
+                    "blood_pressure": extracted_data.vital_signs.blood_pressure if extracted_data.vital_signs else None,
+                    "heart_rate": extracted_data.vital_signs.heart_rate if extracted_data.vital_signs else None,
+                    "temperature": extracted_data.vital_signs.temperature if extracted_data.vital_signs else None,
+                    "respiratory_rate": extracted_data.vital_signs.respiratory_rate if extracted_data.vital_signs else None,
+                    "oxygen_saturation": extracted_data.vital_signs.oxygen_saturation if extracted_data.vital_signs else None
+                } if extracted_data.vital_signs else None,
+                "lab_results": [
+                    {
+                        "test_name": lab.test_name,
+                        "value": lab.value,
+                        "unit": lab.unit,
+                        "reference_range": lab.reference_range
+                    }
+                    for lab in extracted_data.lab_results or []
+                ],
+                "procedures": extracted_data.procedures or [],
+                "notes": extracted_data.notes or ""
+            },
+            "message": "Document analyzed successfully. Review the data before saving."
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger().error(f"Error in document preview: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/save-document-analysis", response_model=dict)
+async def save_document_analysis(
+    patient_id: str = Form(...),
+    filename: str = Form(...),
+    extracted_data: str = Form(...),  # JSON string
+    confidence_score: float = Form(...),
+    emr_update_service: EMRUpdateService = Depends(get_emr_update_service)
+):
+    """Save document analysis results to EMR database."""
+    try:
+        import json
+        
+        # Validate inputs
+        if not patient_id or not patient_id.strip():
+            raise HTTPException(status_code=400, detail="Patient ID is required")
+        if not filename or not filename.strip():
+            raise HTTPException(status_code=400, detail="Filename is required")
+        if not extracted_data or not extracted_data.strip():
+            raise HTTPException(status_code=400, detail="Extracted data is required")
+
+        # Parse extracted data
+        try:
+            data_dict = json.loads(extracted_data)
+        except json.JSONDecodeError as e:
+            raise HTTPException(status_code=400, detail=f"Invalid JSON in extracted data: {e}")
+
+        # Convert to ExtractedData object
+        extracted_data_obj = ExtractedData(
+            diagnosis=data_dict.get('diagnosis', []),
+            symptoms=data_dict.get('symptoms', []),
+            medications=[
+                {
+                    "name": med.get('name', ''),
+                    "dosage": med.get('dosage'),
+                    "frequency": med.get('frequency'),
+                    "duration": med.get('duration')
+                }
+                for med in data_dict.get('medications', [])
+            ],
+            vital_signs=data_dict.get('vital_signs'),
+            lab_results=[
+                {
+                    "test_name": lab.get('test_name', ''),
+                    "value": lab.get('value', ''),
+                    "unit": lab.get('unit'),
+                    "reference_range": lab.get('reference_range')
+                }
+                for lab in data_dict.get('lab_results', [])
+            ],
+            procedures=data_dict.get('procedures', []),
+            notes=data_dict.get('notes', '') + (f"\n\nDocument Overview: {data_dict.get('overview', '')}" if data_dict.get('overview') else '')
+        )
+
+        logger().info(f"Saving document analysis for patient {patient_id}, file: {filename}")
+
+        # Save to database (without file content for preview saves)
+        emr_id = await emr_update_service.save_document_analysis(
+            patient_id=patient_id,
+            filename=filename,
+            file_content=b"",  # Empty for preview saves
+            extracted_data=extracted_data_obj,
+            confidence_score=confidence_score
+        )
+
+        return {
+            "emr_id": emr_id,
+            "message": "Document analysis saved to EMR successfully"
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger().error(f"Error saving document analysis: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

src/api/routes/migration.py

@@ -0,0 +1,41 @@
+# src/api/routes/migration.py
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from typing import Dict, Any
+
+from src.core.state import AppState, get_state
+from src.data.migration import run_database_migration
+from src.utils.logger import logger
+
+router = APIRouter(prefix="/migration", tags=["Migration"])
+
+@router.post("/fix-database", response_model=Dict[str, Any])
+async def fix_database_records(
+    state: AppState = Depends(get_state)
+):
+    """
+    Fix existing database records that have missing or invalid required fields.
+    This endpoint ensures all records conform to current Pydantic model requirements.
+    """
+    logger().info("Migration endpoint called - starting database fix")
+    
+    try:
+        result = run_database_migration()
+        
+        if result['success']:
+            return {
+                "message": "Database migration completed successfully",
+                "stats": result
+            }
+        else:
+            raise HTTPException(
+                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                detail=f"Migration failed: {result.get('error', 'Unknown error')}"
+            )
+            
+    except Exception as e:
+        logger().error(f"Migration endpoint error: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Migration failed: {str(e)}"
+        )

src/api/routes/session.py

@@ -8,6 +8,7 @@ from src.core.state import AppState, get_state
 from src.models.session import (ChatRequest, ChatResponse, Message, Session,
                                 SessionCreateRequest)
 from src.services.medical_response import generate_medical_response
+from src.services.guard import SafetyGuard
 from src.utils.logger import logger
 
 router = APIRouter(prefix="/session", tags=["Session & Chat"])
@@ -85,6 +86,22 @@ async def post_chat_message(
 	"""
 	logger().info(f"POST /session/{session_id}/messages")
 
+	# 0. Safety Guard: Validate user query
+	try:
+		safety_guard = SafetyGuard(state.nvidia_rotator)
+		is_safe, safety_reason = safety_guard.check_user_query(req.message)
+		if not is_safe:
+			logger().warning(f"Safety guard blocked user query: {safety_reason}")
+			raise HTTPException(
+				status_code=status.HTTP_400_BAD_REQUEST, 
+				detail=f"Query blocked for safety reasons: {safety_reason}"
+			)
+		logger().info(f"User query passed safety validation: {safety_reason}")
+	except Exception as e:
+		logger().error(f"Safety guard error: {e}")
+		# Fail open for now - allow query through if guard fails
+		logger().warning("Safety guard failed, allowing query through")
+
 	# 1. Get Enhanced Context
 	try:
 		medical_context = await state.memory_manager.get_enhanced_context(
@@ -105,12 +122,27 @@ async def post_chat_message(
 			user_role="Medical Professional",
 			user_specialty="",
 			rotator=state.gemini_rotator,
-			medical_context=medical_context
+			medical_context=medical_context,
+			nvidia_rotator=state.nvidia_rotator
 		)
 	except Exception as e:
 		logger().error(f"Error generating medical response: {e}")
 		raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Failed to generate AI response.")
 
+	# 2.5. Safety Guard: Validate AI response
+	try:
+		is_safe, safety_reason = safety_guard.check_model_answer(req.message, response_text)
+		if not is_safe:
+			logger().warning(f"Safety guard blocked AI response: {safety_reason}")
+			# Replace with safe fallback response
+			response_text = "I apologize, but I cannot provide a response to that query as it may contain unsafe content. Please consult with a qualified healthcare professional for medical advice."
+		else:
+			logger().info(f"AI response passed safety validation: {safety_reason}")
+	except Exception as e:
+		logger().error(f"Safety guard error for response: {e}")
+		# Fail open for now - allow response through if guard fails
+		logger().warning("Safety guard failed for response, allowing through")
+
 	# 3. Process and Store the Exchange
 	summary = await state.memory_manager.process_medical_exchange(
 		session_id=session_id,

src/config/settings.py

@@ -1,4 +1,5 @@
 # src/config/settings.py
+import os
 
 class Settings:
 	"""Application-wide settings."""
@@ -7,6 +8,11 @@ class Settings:
 	DEFAULT_TOP_K: int = 5
 	SEMANTIC_CONTEXT_SIZE: int = 17
 	SIMILARITY_THRESHOLD: float = 0.15
+	
+	# Safety Guard settings
+	SAFETY_GUARD_ENABLED: bool = os.getenv("SAFETY_GUARD_ENABLED", "true").lower() == "true"
+	SAFETY_GUARD_TIMEOUT: int = int(os.getenv("SAFETY_GUARD_TIMEOUT", "30"))
+	SAFETY_GUARD_FAIL_OPEN: bool = os.getenv("SAFETY_GUARD_FAIL_OPEN", "true").lower() == "true"
 
 # Create singleton instance
 settings = Settings()

src/data/emr_update.py

@@ -0,0 +1,315 @@
+# src/data/emr_update.py
+
+import os
+import uuid
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from src.data.connection import get_database
+from src.models.emr import ExtractedData
+from src.utils.logger import logger
+
+
+class EMRUpdateService:
+    """Service for updating EMR records with document analysis results."""
+
+    def __init__(self):
+        self.db = get_database()
+
+    async def save_document_analysis(
+        self,
+        patient_id: str,
+        filename: str,
+        file_content: bytes,
+        extracted_data: ExtractedData,
+        confidence_score: float,
+        original_message: str = None
+    ) -> str:
+        """
+        Save document analysis results to the EMR database.
+
+        Args:
+            patient_id: The ID of the patient
+            filename: The name of the uploaded file
+            file_content: The binary content of the file
+            extracted_data: The extracted medical data
+            confidence_score: The confidence score of the analysis
+            original_message: Optional original message (for chat-based entries)
+
+        Returns:
+            The EMR ID of the created record
+        """
+        try:
+            # Generate unique EMR ID
+            emr_id = str(uuid.uuid4())
+            
+            # Prepare the EMR record
+            emr_record = {
+                "emr_id": emr_id,
+                "patient_id": patient_id,
+                "original_message": original_message or f"Document upload: {filename}",
+                "extracted_data": {
+                    "diagnosis": extracted_data.diagnosis or [],
+                    "symptoms": extracted_data.symptoms or [],
+                    "medications": [
+                        {
+                            "name": med.name,
+                            "dosage": med.dosage,
+                            "frequency": med.frequency,
+                            "duration": med.duration
+                        }
+                        for med in extracted_data.medications or []
+                    ],
+                    "vital_signs": {
+                        "blood_pressure": extracted_data.vital_signs.blood_pressure if extracted_data.vital_signs else None,
+                        "heart_rate": extracted_data.vital_signs.heart_rate if extracted_data.vital_signs else None,
+                        "temperature": extracted_data.vital_signs.temperature if extracted_data.vital_signs else None,
+                        "respiratory_rate": extracted_data.vital_signs.respiratory_rate if extracted_data.vital_signs else None,
+                        "oxygen_saturation": extracted_data.vital_signs.oxygen_saturation if extracted_data.vital_signs else None
+                    } if extracted_data.vital_signs else None,
+                    "lab_results": [
+                        {
+                            "test_name": lab.test_name,
+                            "value": lab.value,
+                            "unit": lab.unit,
+                            "reference_range": lab.reference_range
+                        }
+                        for lab in extracted_data.lab_results or []
+                    ],
+                    "procedures": extracted_data.procedures or [],
+                    "notes": extracted_data.notes or ""
+                },
+                "confidence_score": confidence_score,
+                "source": "document_upload",
+                "filename": filename,
+                "created_at": datetime.utcnow(),
+                "updated_at": datetime.utcnow()
+            }
+
+            # Save to database
+            result = await self.db.emr_records.insert_one(emr_record)
+            
+            if result.inserted_id:
+                logger().info(f"Successfully saved document analysis for patient {patient_id}, EMR ID: {emr_id}")
+                return emr_id
+            else:
+                raise Exception("Failed to insert EMR record")
+
+        except Exception as e:
+            logger().error(f"Error saving document analysis: {e}")
+            raise
+
+    async def update_emr_record(
+        self,
+        emr_id: str,
+        extracted_data: ExtractedData,
+        confidence_score: float = None
+    ) -> bool:
+        """
+        Update an existing EMR record with new extracted data.
+
+        Args:
+            emr_id: The EMR record ID to update
+            extracted_data: The updated extracted medical data
+            confidence_score: Optional new confidence score
+
+        Returns:
+            True if update was successful, False otherwise
+        """
+        try:
+            # Prepare update data
+            update_data = {
+                "extracted_data": {
+                    "diagnosis": extracted_data.diagnosis or [],
+                    "symptoms": extracted_data.symptoms or [],
+                    "medications": [
+                        {
+                            "name": med.name,
+                            "dosage": med.dosage,
+                            "frequency": med.frequency,
+                            "duration": med.duration
+                        }
+                        for med in extracted_data.medications or []
+                    ],
+                    "vital_signs": {
+                        "blood_pressure": extracted_data.vital_signs.blood_pressure if extracted_data.vital_signs else None,
+                        "heart_rate": extracted_data.vital_signs.heart_rate if extracted_data.vital_signs else None,
+                        "temperature": extracted_data.vital_signs.temperature if extracted_data.vital_signs else None,
+                        "respiratory_rate": extracted_data.vital_signs.respiratory_rate if extracted_data.vital_signs else None,
+                        "oxygen_saturation": extracted_data.vital_signs.oxygen_saturation if extracted_data.vital_signs else None
+                    } if extracted_data.vital_signs else None,
+                    "lab_results": [
+                        {
+                            "test_name": lab.test_name,
+                            "value": lab.value,
+                            "unit": lab.unit,
+                            "reference_range": lab.reference_range
+                        }
+                        for lab in extracted_data.lab_results or []
+                    ],
+                    "procedures": extracted_data.procedures or [],
+                    "notes": extracted_data.notes or ""
+                },
+                "updated_at": datetime.utcnow()
+            }
+
+            if confidence_score is not None:
+                update_data["confidence_score"] = confidence_score
+
+            # Update the record
+            result = await self.db.emr_records.update_one(
+                {"emr_id": emr_id},
+                {"$set": update_data}
+            )
+
+            if result.modified_count > 0:
+                logger().info(f"Successfully updated EMR record {emr_id}")
+                return True
+            else:
+                logger().warning(f"No EMR record found with ID {emr_id}")
+                return False
+
+        except Exception as e:
+            logger().error(f"Error updating EMR record {emr_id}: {e}")
+            raise
+
+    async def get_emr_record(self, emr_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Retrieve an EMR record by ID.
+
+        Args:
+            emr_id: The EMR record ID
+
+        Returns:
+            The EMR record if found, None otherwise
+        """
+        try:
+            record = await self.db.emr_records.find_one({"emr_id": emr_id})
+            if record:
+                # Convert ObjectId to string for JSON serialization
+                record["_id"] = str(record["_id"])
+            return record
+
+        except Exception as e:
+            logger().error(f"Error retrieving EMR record {emr_id}: {e}")
+            raise
+
+    async def delete_emr_record(self, emr_id: str) -> bool:
+        """
+        Delete an EMR record.
+
+        Args:
+            emr_id: The EMR record ID to delete
+
+        Returns:
+            True if deletion was successful, False otherwise
+        """
+        try:
+            result = await self.db.emr_records.delete_one({"emr_id": emr_id})
+            
+            if result.deleted_count > 0:
+                logger().info(f"Successfully deleted EMR record {emr_id}")
+                return True
+            else:
+                logger().warning(f"No EMR record found with ID {emr_id}")
+                return False
+
+        except Exception as e:
+            logger().error(f"Error deleting EMR record {emr_id}: {e}")
+            raise
+
+    async def get_patient_emr_records(
+        self,
+        patient_id: str,
+        limit: int = 100,
+        skip: int = 0
+    ) -> List[Dict[str, Any]]:
+        """
+        Retrieve EMR records for a specific patient.
+
+        Args:
+            patient_id: The patient ID
+            limit: Maximum number of records to return
+            skip: Number of records to skip
+
+        Returns:
+            List of EMR records
+        """
+        try:
+            cursor = self.db.emr_records.find(
+                {"patient_id": patient_id}
+            ).sort("created_at", -1).skip(skip).limit(limit)
+
+            records = []
+            async for record in cursor:
+                # Convert ObjectId to string for JSON serialization
+                record["_id"] = str(record["_id"])
+                records.append(record)
+
+            return records
+
+        except Exception as e:
+            logger().error(f"Error retrieving EMR records for patient {patient_id}: {e}")
+            raise
+
+    async def get_patient_emr_statistics(self, patient_id: str) -> Dict[str, Any]:
+        """
+        Get EMR statistics for a patient.
+
+        Args:
+            patient_id: The patient ID
+
+        Returns:
+            Dictionary containing EMR statistics
+        """
+        try:
+            pipeline = [
+                {"$match": {"patient_id": patient_id}},
+                {
+                    "$group": {
+                        "_id": None,
+                        "total_entries": {"$sum": 1},
+                        "avg_confidence": {"$avg": "$confidence_score"},
+                        "diagnosis_count": {
+                            "$sum": {
+                                "$cond": [
+                                    {"$gt": [{"$size": {"$ifNull": ["$extracted_data.diagnosis", []]}}, 0]},
+                                    1,
+                                    0
+                                ]
+                            }
+                        },
+                        "medication_count": {
+                            "$sum": {
+                                "$cond": [
+                                    {"$gt": [{"$size": {"$ifNull": ["$extracted_data.medications", []]}}, 0]},
+                                    1,
+                                    0
+                                ]
+                            }
+                        }
+                    }
+                }
+            ]
+
+            result = await self.db.emr_records.aggregate(pipeline).to_list(1)
+            
+            if result:
+                stats = result[0]
+                return {
+                    "total_entries": stats.get("total_entries", 0),
+                    "avg_confidence": stats.get("avg_confidence", 0.0),
+                    "diagnosis_count": stats.get("diagnosis_count", 0),
+                    "medication_count": stats.get("medication_count", 0)
+                }
+            else:
+                return {
+                    "total_entries": 0,
+                    "avg_confidence": 0.0,
+                    "diagnosis_count": 0,
+                    "medication_count": 0
+                }
+
+        except Exception as e:
+            logger().error(f"Error retrieving EMR statistics for patient {patient_id}: {e}")
+            raise

src/data/migration.py

@@ -0,0 +1,237 @@
+# src/data/migration.py
+"""
+Database Migration Module
+
+This module provides functions to fix existing database records that have 
+missing or invalid required fields to ensure they conform to current Pydantic model requirements.
+"""
+
+from datetime import datetime, timezone
+from typing import Dict, Any
+
+from bson import ObjectId
+from pymongo.errors import ConnectionFailure, PyMongoError
+
+from src.data.connection import get_collection, Collections
+from src.models.account import Account
+from src.models.patient import Patient
+from src.utils.logger import logger
+
+# Valid roles for accounts
+VALID_ROLES = [
+    "Doctor",
+    "Healthcare Prof", 
+    "Nurse",
+    "Caregiver",
+    "Physician",
+    "Medical Student",
+    "Other"
+]
+
+def fix_account_records() -> Dict[str, int]:
+    """Fix account records with missing or invalid required fields."""
+    logger().info("🔧 Starting Account records migration...")
+    
+    collection = get_collection(Collections.ACCOUNT)
+    now = datetime.now(timezone.utc)
+    
+    stats = {
+        'total_checked': 0,
+        'fixed': 0,
+        'errors': 0
+    }
+    
+    try:
+        # Find all accounts
+        cursor = collection.find({})
+        
+        for doc in cursor:
+            stats['total_checked'] += 1
+            doc_id = doc['_id']
+            
+            try:
+                # Check what needs to be fixed
+                updates = {}
+                needs_fix = False
+                
+                # Fix missing or None role
+                if not doc.get('role') or doc.get('role') is None:
+                    updates['role'] = 'Other'  # Default role
+                    needs_fix = True
+                    logger().info(f"  📝 Account {doc_id}: Setting role to 'Other' (was: {doc.get('role')})")
+                
+                # Fix missing or None name
+                if not doc.get('name') or doc.get('name') is None:
+                    updates['name'] = f"User {str(doc_id)[:8]}"  # Generate a name
+                    needs_fix = True
+                    logger().info(f"  📝 Account {doc_id}: Setting name to '{updates['name']}' (was: {doc.get('name')})")
+                
+                # Fix missing timestamps
+                if not doc.get('created_at'):
+                    updates['created_at'] = now
+                    needs_fix = True
+                    logger().info(f"  📝 Account {doc_id}: Setting created_at to {now}")
+                
+                if not doc.get('updated_at'):
+                    updates['updated_at'] = now
+                    needs_fix = True
+                    logger().info(f"  📝 Account {doc_id}: Setting updated_at to {now}")
+                
+                # Apply updates if needed
+                if needs_fix:
+                    collection.update_one(
+                        {"_id": doc_id},
+                        {"$set": updates}
+                    )
+                    stats['fixed'] += 1
+                
+                # Validate the record can be parsed by Pydantic
+                updated_doc = collection.find_one({"_id": doc_id})
+                Account.model_validate(updated_doc)
+                
+            except Exception as e:
+                stats['errors'] += 1
+                logger().error(f"  ❌ Error fixing account {doc_id}: {e}")
+                
+    except (ConnectionFailure, PyMongoError) as e:
+        logger().error(f"❌ Database error while fixing accounts: {e}")
+        raise
+    
+    logger().info(f"✅ Account migration completed: {stats['fixed']} records fixed, {stats['errors']} errors")
+    return stats
+
+def fix_patient_records() -> Dict[str, int]:
+    """Fix patient records with missing or invalid required fields."""
+    logger().info("🔧 Starting Patient records migration...")
+    
+    collection = get_collection(Collections.PATIENT)
+    now = datetime.now(timezone.utc)
+    
+    stats = {
+        'total_checked': 0,
+        'fixed': 0,
+        'errors': 0
+    }
+    
+    try:
+        # Find all patients
+        cursor = collection.find({})
+        
+        for doc in cursor:
+            stats['total_checked'] += 1
+            doc_id = doc['_id']
+            
+            try:
+                # Check what needs to be fixed
+                updates = {}
+                needs_fix = False
+                
+                # Fix missing or None name
+                if not doc.get('name') or doc.get('name') is None:
+                    updates['name'] = f"Patient {str(doc_id)[:8]}"  # Generate a name
+                    needs_fix = True
+                    logger().info(f"  📝 Patient {doc_id}: Setting name to '{updates['name']}' (was: {doc.get('name')})")
+                
+                # Fix missing or None age
+                if not doc.get('age') or doc.get('age') is None:
+                    updates['age'] = 30  # Default age
+                    needs_fix = True
+                    logger().info(f"  📝 Patient {doc_id}: Setting age to 30 (was: {doc.get('age')})")
+                
+                # Fix missing or None sex
+                if not doc.get('sex') or doc.get('sex') is None:
+                    updates['sex'] = 'Other'  # Default sex
+                    needs_fix = True
+                    logger().info(f"  📝 Patient {doc_id}: Setting sex to 'Other' (was: {doc.get('sex')})")
+                
+                # Fix missing or None ethnicity
+                if not doc.get('ethnicity') or doc.get('ethnicity') is None:
+                    updates['ethnicity'] = 'Not Specified'  # Default ethnicity
+                    needs_fix = True
+                    logger().info(f"  📝 Patient {doc_id}: Setting ethnicity to 'Not Specified' (was: {doc.get('ethnicity')})")
+                
+                # Fix missing timestamps
+                if not doc.get('created_at'):
+                    updates['created_at'] = now
+                    needs_fix = True
+                    logger().info(f"  📝 Patient {doc_id}: Setting created_at to {now}")
+                
+                if not doc.get('updated_at'):
+                    updates['updated_at'] = now
+                    needs_fix = True
+                    logger().info(f"  📝 Patient {doc_id}: Setting updated_at to {now}")
+                
+                # Apply updates if needed
+                if needs_fix:
+                    collection.update_one(
+                        {"_id": doc_id},
+                        {"$set": updates}
+                    )
+                    stats['fixed'] += 1
+                
+                # Validate the record can be parsed by Pydantic
+                updated_doc = collection.find_one({"_id": doc_id})
+                Patient.model_validate(updated_doc)
+                
+            except Exception as e:
+                stats['errors'] += 1
+                logger().error(f"  ❌ Error fixing patient {doc_id}: {e}")
+                
+    except (ConnectionFailure, PyMongoError) as e:
+        logger().error(f"❌ Database error while fixing patients: {e}")
+        raise
+    
+    logger().info(f"✅ Patient migration completed: {stats['fixed']} records fixed, {stats['errors']} errors")
+    return stats
+
+def run_database_migration() -> Dict[str, Any]:
+    """Run the complete database migration to fix all records."""
+    logger().info("🚀 Starting Database Migration")
+    logger().info("=" * 50)
+    
+    try:
+        # Fix account records
+        account_stats = fix_account_records()
+        
+        logger().info("=" * 50)
+        
+        # Fix patient records  
+        patient_stats = fix_patient_records()
+        
+        logger().info("=" * 50)
+        logger().info("📊 MIGRATION SUMMARY")
+        logger().info("=" * 50)
+        
+        logger().info(f"📋 Accounts:")
+        logger().info(f"  - Total checked: {account_stats['total_checked']}")
+        logger().info(f"  - Fixed: {account_stats['fixed']}")
+        logger().info(f"  - Errors: {account_stats['errors']}")
+        
+        logger().info(f"👥 Patients:")
+        logger().info(f"  - Total checked: {patient_stats['total_checked']}")
+        logger().info(f"  - Fixed: {patient_stats['fixed']}")
+        logger().info(f"  - Errors: {patient_stats['errors']}")
+        
+        total_fixed = account_stats['fixed'] + patient_stats['fixed']
+        total_errors = account_stats['errors'] + patient_stats['errors']
+        
+        logger().info(f"✅ Total records fixed: {total_fixed}")
+        if total_errors > 0:
+            logger().info(f"⚠️  Total errors: {total_errors}")
+        
+        logger().info("🎉 Database migration completed successfully!")
+        
+        return {
+            'account_stats': account_stats,
+            'patient_stats': patient_stats,
+            'total_fixed': total_fixed,
+            'total_errors': total_errors,
+            'success': True
+        }
+        
+    except Exception as e:
+        logger().error(f"❌ Migration failed with error: {e}")
+        return {
+            'success': False,
+            'error': str(e)
+        }

src/data/repositories/account.py

@@ -191,11 +191,23 @@ def search_accounts(
 
 	try:
 		collection = get_collection(collection_name)
+		now = datetime.now(timezone.utc)
+		
 		cursor = collection.find({
 			"name": {"$regex": pattern}
 		}).sort("name", ASCENDING).limit(limit)
 
-		accounts = [Account.model_validate(doc) for doc in cursor]
+		accounts = []
+		for doc in cursor:
+			# Update last_seen for this account
+			collection.update_one(
+				{"_id": doc["_id"]},
+				{"$set": {"last_seen": now}}
+			)
+			# Add the updated timestamp to the document for validation
+			doc["last_seen"] = now
+			accounts.append(Account.model_validate(doc))
+		
 		logger().info(f"Found {len(accounts)} accounts matching query")
 		return accounts
 	except (ConnectionFailure, PyMongoError) as e:
@@ -210,9 +222,25 @@ def get_all_accounts(
 	"""Gets all accounts, returning a list of Pydantic Account objects."""
 	try:
 		collection = get_collection(collection_name)
-		cursor = collection.find().sort("name", ASCENDING).limit(limit)
-
-		accounts = [Account.model_validate(doc) for doc in cursor]
+		now = datetime.now(timezone.utc)
+		
+		# Update last_seen for all accounts and retrieve them
+		cursor = collection.find()
+		accounts = []
+		for doc in cursor:
+			# Update last_seen for this account
+			collection.update_one(
+				{"_id": doc["_id"]},
+				{"$set": {"last_seen": now}}
+			)
+			# Add the updated timestamp to the document for validation
+			doc["last_seen"] = now
+			accounts.append(Account.model_validate(doc))
+		
+		# Sort by name and limit
+		accounts.sort(key=lambda x: x.name)
+		accounts = accounts[:limit]
+		
 		logger().info(f"Retrieved {len(accounts)} accounts")
 		return accounts
 	except (ConnectionFailure, PyMongoError) as e:

src/main.py

@@ -27,6 +27,7 @@ except Exception as e:
 from src.api.routes import account as account_route
 from src.api.routes import audio as audio_route
 from src.api.routes import emr as emr_route
+from src.api.routes import migration as migration_route
 from src.api.routes import patient as patients_route
 from src.api.routes import session as session_route
 from src.api.routes import static as static_route
@@ -86,6 +87,18 @@ def startup_event(state: AppState):
 	medical_memory_repo.init()
 	medical_record_repo.init()
 	emr_repo.init()
+	
+	# Run database migration to fix any existing records with missing required fields
+	try:
+		from src.data.migration import run_database_migration
+		logger(tag="startup").info("Running database migration...")
+		migration_result = run_database_migration()
+		if migration_result['success']:
+			logger(tag="startup").info(f"Database migration completed: {migration_result['total_fixed']} records fixed")
+		else:
+			logger(tag="startup").warning(f"Database migration failed: {migration_result.get('error', 'Unknown error')}")
+	except Exception as e:
+		logger(tag="startup").warning(f"Database migration error: {e}")
 
 def shutdown_event():
 	"""Cleanup on shutdown"""
@@ -132,6 +145,7 @@ app.include_router(summarise_route.router)
 app.include_router(system_route.router)
 app.include_router(audio_route.router)
 app.include_router(emr_route.router)
+app.include_router(migration_route.router)
 
 @app.get("/api/info")
 async def get_api_info():

src/models/account.py

@@ -14,7 +14,7 @@ class Account(BaseMongoModel):
 	specialty: str | None = None
 	created_at: datetime
 	updated_at: datetime
-	last_seen: datetime
+	last_seen: datetime | None = None
 
 class AccountCreateRequest(BaseModel):
 	"""A Pydantic model for an account creation request from the API."""

src/services/extractor.py

@@ -2,6 +2,8 @@
 
 import json
 import re
+import base64
+import mimetypes
 from typing import Any, Dict, List, Optional, Tuple
 
 from src.models.emr import ExtractedData, LabResult, Medication, VitalSigns
@@ -192,7 +194,7 @@ Return the JSON followed by the confidence score on a new line."""
                 vital_signs=vital_signs,
                 lab_results=lab_results,
                 procedures=data.get('procedures', []),
-                notes=data.get('notes')
+                notes=data.get('notes', '') + (f"\n\nDocument Overview: {data.get('overview', '')}" if data.get('overview') else '')
             )
 
             return extracted_data, confidence
@@ -258,3 +260,141 @@ Return the JSON followed by the confidence score on a new line."""
             vital_signs['oxygen_saturation'] = o2_match.group(1)
 
         return vital_signs
+
+    async def analyze_document(self, file_content: bytes, filename: str, patient_context: Optional[Dict[str, Any]] = None) -> Tuple[ExtractedData, float]:
+        """
+        Analyze a medical document (PDF, image, or text) and extract structured medical data.
+
+        Args:
+            file_content: The binary content of the uploaded file
+            filename: The name of the uploaded file
+            patient_context: Optional patient context information
+
+        Returns:
+            Tuple of (ExtractedData, confidence_score)
+        """
+        try:
+            # Determine file type and prepare content for Gemini
+            mime_type, _ = mimetypes.guess_type(filename)
+            
+            if not mime_type:
+                logger().warning(f"Unknown file type for {filename}")
+                return ExtractedData(), 0.0
+
+            # Encode file content to base64
+            file_base64 = base64.b64encode(file_content).decode('utf-8')
+            
+            # Build the prompt for document analysis
+            prompt = self._build_document_analysis_prompt(file_base64, mime_type, filename, patient_context)
+
+            # Get response from Gemini
+            response = await self._call_gemini_api(prompt)
+
+            # Parse the response
+            extracted_data, confidence = self._parse_gemini_response(response)
+
+            logger().info(f"Successfully analyzed document {filename} with confidence {confidence:.2f}")
+            return extracted_data, confidence
+
+        except Exception as e:
+            logger().error(f"Error analyzing document {filename}: {e}")
+            # Return empty data with low confidence
+            return ExtractedData(), 0.0
+
+    def _build_document_analysis_prompt(self, file_base64: str, mime_type: str, filename: str, patient_context: Optional[Dict[str, Any]] = None) -> str:
+        """Build the prompt for Gemini AI to analyze medical documents."""
+        
+        context_info = ""
+        if patient_context:
+            context_info = f"""
+Patient Context:
+- Name: {patient_context.get('name', 'Unknown')}
+- Age: {patient_context.get('age', 'Unknown')}
+- Sex: {patient_context.get('sex', 'Unknown')}
+- Current Medications: {', '.join(patient_context.get('medications', []))}
+- Past Assessment Summary: {patient_context.get('past_assessment_summary', 'None')}
+"""
+
+        # Determine the content type for Gemini
+        if mime_type.startswith('image/'):
+            content_type = "image"
+        elif mime_type == 'application/pdf':
+            content_type = "pdf"
+        elif mime_type in ['application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document']:
+            content_type = "document"
+        else:
+            content_type = "text"
+
+        prompt = f"""You are a medical AI assistant specialized in analyzing medical documents and extracting structured clinical information.
+
+{context_info}
+
+Please analyze the following medical document and extract all relevant clinical information in the specified JSON format.
+
+Document Information:
+- Filename: {filename}
+- Content Type: {content_type}
+- MIME Type: {mime_type}
+
+Document Content (Base64 encoded):
+{file_base64}
+
+Extract the following information and return ONLY a valid JSON object with this exact structure:
+
+{{
+    "overview": "Brief summary of the document content and main findings",
+    "diagnosis": ["list of diagnoses mentioned or identified"],
+    "symptoms": ["list of symptoms described"],
+    "medications": [
+        {{
+            "name": "medication name",
+            "dosage": "dosage if mentioned",
+            "frequency": "frequency if mentioned",
+            "duration": "duration if mentioned"
+        }}
+    ],
+    "vital_signs": {{
+        "blood_pressure": "value if mentioned",
+        "heart_rate": "value if mentioned",
+        "temperature": "value if mentioned",
+        "respiratory_rate": "value if mentioned",
+        "oxygen_saturation": "value if mentioned"
+    }},
+    "lab_results": [
+        {{
+            "test_name": "test name",
+            "value": "test value",
+            "unit": "unit if mentioned",
+            "reference_range": "normal range if mentioned"
+        }}
+    ],
+    "procedures": ["list of procedures mentioned or performed"],
+    "notes": "additional clinical notes and observations"
+}}
+
+Guidelines for Document Analysis:
+1. Carefully read and analyze the entire document content
+2. Extract information that is explicitly mentioned or clearly documented
+3. Use medical terminology appropriately and maintain accuracy
+4. If a field has no relevant information, use an empty array [] or null
+5. For medications, include all prescribed, recommended, or mentioned medications
+6. Extract vital signs only if specific values are documented
+7. Include lab results only if specific test values are provided
+8. Be thorough but conservative - prioritize accuracy over completeness
+9. For images, focus on visible text, charts, and medical data
+10. For PDFs and documents, analyze all text content systematically
+11. Return ONLY the JSON object, no additional text or explanation
+
+Confidence Assessment:
+After the JSON, provide a confidence score (0.0-1.0) based on:
+- Document clarity and readability
+- Specificity of medical information
+- Presence of measurable values (vitals, lab results)
+- Overall clinical relevance and completeness
+- Document type and quality
+
+Format: CONFIDENCE: 0.85
+
+Return the JSON followed by the confidence score on a new line."""
+
+        return prompt

src/services/guard.py

@@ -0,0 +1,518 @@
+import os
+import re
+import requests
+import logging
+from typing import Tuple, List, Dict
+
+from src.config.settings import settings
+from src.utils.rotator import APIKeyRotator
+
+logger = logging.getLogger(__name__)
+
+
+class SafetyGuard:
+    """
+    Wrapper around NVIDIA Llama Guard (meta/llama-guard-4-12b) hosted at
+    https://integrate.api.nvidia.com/v1/chat/completions
+
+    Exposes helpers to validate:
+      - user input safety
+      - model output safety (in context of the user question)
+    """
+    NVIDIA_GUARD = os.getenv("NVIDIA_GUARD", "meta/llama-guard-4-12b")
+
+    def __init__(self, nvidia_rotator: APIKeyRotator = None):
+        self.nvidia_rotator = nvidia_rotator or APIKeyRotator("NVIDIA_API_", max_slots=5)
+        if not self.nvidia_rotator.get_key():
+            raise ValueError("No NVIDIA API keys found. Set NVIDIA_API_1, NVIDIA_API_2, etc. environment variables")
+        self.base_url = "https://integrate.api.nvidia.com/v1/chat/completions"
+        self.model = NVIDIA_GUARD
+        self.timeout_s = settings.SAFETY_GUARD_TIMEOUT
+        self.enabled = settings.SAFETY_GUARD_ENABLED
+        self.fail_open = settings.SAFETY_GUARD_FAIL_OPEN
+
+    @staticmethod
+    def _chunk_text(text: str, chunk_size: int = 2800, overlap: int = 200) -> List[str]:
+        """Chunk long text to keep request payloads small enough for the guard.
+        Uses character-based approximation with small overlap.
+        """
+        if not text:
+            return [""]
+        n = len(text)
+        if n <= chunk_size:
+            return [text]
+        chunks: List[str] = []
+        start = 0
+        while start < n:
+            end = min(start + chunk_size, n)
+            chunks.append(text[start:end])
+            if end == n:
+                break
+            start = max(0, end - overlap)
+        return chunks
+
+    def _call_guard(self, messages: List[Dict], max_tokens: int = 512) -> str:
+        # Enhance messages with medical context if detected
+        enhanced_messages = self._enhance_messages_with_context(messages)
+        
+        api_key = self.nvidia_rotator.get_key()
+        if not api_key:
+            logger.error("[SafetyGuard] No NVIDIA API key available")
+            return ""
+        
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+        # Try OpenAI-compatible schema first
+        payload_chat = {
+            "model": self.model,
+            "messages": enhanced_messages,
+            "temperature": 0.2,
+            "top_p": 0.7,
+            "max_tokens": max_tokens,
+            "stream": False,
+        }
+        # Alternative schema (some NVIDIA deployments require message content objects)
+        alt_messages = []
+        for m in enhanced_messages:
+            content = m.get("content", "")
+            if isinstance(content, str):
+                content = [{"type": "text", "text": content}]
+            alt_messages.append({"role": m.get("role", "user"), "content": content})
+        payload_alt = {
+            "model": self.model,
+            "messages": alt_messages,
+            "temperature": 0.2,
+            "top_p": 0.7,
+            "max_tokens": max_tokens,
+            "stream": False,
+        }
+        # Attempt primary, then fallback
+        for payload in (payload_chat, payload_alt):
+            try:
+                resp = requests.post(self.base_url, headers=headers, json=payload, timeout=self.timeout_s)
+                if resp.status_code in {401, 403, 429} or 500 <= resp.status_code < 600:
+                    # Rotate API key and retry
+                    logger.warning(f"[SafetyGuard] HTTP {resp.status_code}, rotating API key")
+                    self.nvidia_rotator.rotate()
+                    api_key = self.nvidia_rotator.get_key()
+                    if api_key:
+                        headers["Authorization"] = f"Bearer {api_key}"
+                        continue
+                    else:
+                        logger.error("[SafetyGuard] No more API keys available")
+                        return ""
+                elif resp.status_code >= 400:
+                    # Log server message for debugging payload issues
+                    try:
+                        logger.error(f"[SafetyGuard] HTTP {resp.status_code}: {resp.text[:400]}")
+                    except Exception:
+                        pass
+                    resp.raise_for_status()
+                data = resp.json()
+                content = (
+                    data.get("choices", [{}])[0]
+                        .get("message", {})
+                        .get("content", "")
+                        .strip()
+                )
+                if content:
+                    return content
+            except Exception as e:
+                # Try next payload shape
+                logger.error(f"[SafetyGuard] Guard API call failed: {e}")
+                continue
+        # All attempts failed
+        return ""
+
+    @staticmethod
+    def _parse_guard_reply(text: str) -> Tuple[bool, str]:
+        """Parse guard reply; expect 'SAFE' or 'UNSAFE: <reason>' (case-insensitive)."""
+        if not text:
+            # Fail-open: treat as SAFE if guard unavailable to avoid false blocks
+            return True, "guard_unavailable"
+        t = text.strip()
+        upper = t.upper()
+        if upper.startswith("SAFE") and not upper.startswith("SAFEGUARD"):
+            return True, ""
+        if upper.startswith("UNSAFE"):
+            # Extract reason after the first colon if present
+            parts = t.split(":", 1)
+            reason = parts[1].strip() if len(parts) > 1 else "policy violation"
+            return False, reason
+        # Fallback: treat unknown response as unsafe
+        return False, t[:180]
+
+    def _is_medical_query(self, query: str) -> bool:
+        """Check if query is clearly medical in nature using comprehensive patterns."""
+        if not query:
+            return False
+        
+        query_lower = query.lower()
+        
+        # Medical keyword categories
+        medical_categories = {
+            'symptoms': [
+                'symptom', 'pain', 'ache', 'hurt', 'sore', 'tender', 'stiff', 'numb',
+                'headache', 'migraine', 'fever', 'cough', 'cold', 'flu', 'sneeze',
+                'nausea', 'vomit', 'diarrhea', 'constipation', 'bloating', 'gas',
+                'dizziness', 'vertigo', 'fatigue', 'weakness', 'tired', 'exhausted',
+                'shortness of breath', 'wheezing', 'chest pain', 'heart palpitations',
+                'joint pain', 'muscle pain', 'back pain', 'neck pain', 'stomach pain',
+                'abdominal pain', 'pelvic pain', 'menstrual pain', 'cramps'
+            ],
+            'conditions': [
+                'disease', 'condition', 'disorder', 'syndrome', 'illness', 'sickness',
+                'infection', 'inflammation', 'allergy', 'asthma', 'diabetes', 'hypertension',
+                'depression', 'anxiety', 'stress', 'panic', 'phobia', 'ocd', 'ptsd',
+                'adhd', 'autism', 'dementia', 'alzheimer', 'parkinson', 'epilepsy',
+                'cancer', 'tumor', 'cancerous', 'malignant', 'benign', 'metastasis',
+                'heart disease', 'stroke', 'heart attack', 'coronary', 'arrhythmia',
+                'pneumonia', 'bronchitis', 'copd', 'emphysema', 'tuberculosis',
+                'migraine', 'headache', 'chronic migraine', 'cluster headache',
+                'tension headache', 'sinus headache', 'cure', 'treat', 'treatment'
+            ],
+            'treatments': [
+                'treatment', 'therapy', 'medication', 'medicine', 'drug', 'pill', 'tablet',
+                'injection', 'vaccine', 'immunization', 'surgery', 'operation', 'procedure',
+                'chemotherapy', 'radiation', 'physical therapy', 'occupational therapy',
+                'psychotherapy', 'counseling', 'rehabilitation', 'recovery', 'healing',
+                'prescription', 'dosage', 'side effects', 'contraindications'
+            ],
+            'body_parts': [
+                'head', 'brain', 'eye', 'ear', 'nose', 'mouth', 'throat', 'neck',
+                'chest', 'heart', 'lung', 'liver', 'kidney', 'stomach', 'intestine',
+                'back', 'spine', 'joint', 'muscle', 'bone', 'skin', 'hair', 'nail',
+                'arm', 'leg', 'hand', 'foot', 'finger', 'toe', 'pelvis', 'genital'
+            ],
+            'medical_context': [
+                'doctor', 'physician', 'nurse', 'specialist', 'surgeon', 'dentist',
+                'medical', 'health', 'healthcare', 'hospital', 'clinic', 'emergency',
+                'ambulance', 'paramedic', 'pharmacy', 'pharmacist', 'lab', 'test',
+                'diagnosis', 'prognosis', 'examination', 'checkup', 'screening',
+                'patient', 'case', 'history', 'medical history', 'family history'
+            ],
+            'life_stages': [
+                'pregnancy', 'pregnant', 'baby', 'infant', 'newborn', 'child', 'pediatric',
+                'teenager', 'adolescent', 'adult', 'elderly', 'senior', 'geriatric',
+                'menopause', 'puberty', 'aging', 'birth', 'delivery', 'miscarriage'
+            ],
+            'vital_signs': [
+                'blood pressure', 'heart rate', 'pulse', 'temperature', 'fever',
+                'respiratory rate', 'oxygen saturation', 'weight', 'height', 'bmi',
+                'blood sugar', 'glucose', 'cholesterol', 'hemoglobin', 'white blood cell'
+            ]
+        }
+        
+        # Check for medical keywords
+        for category, keywords in medical_categories.items():
+            if any(keyword in query_lower for keyword in keywords):
+                return True
+        
+        # Check for medical question patterns
+        medical_patterns = [
+            r'\b(what|how|why|when|where)\s+(causes?|treats?|prevents?|symptoms?|signs?)\b',
+            r'\b(is|are)\s+(.*?)\s+(dangerous|serious|harmful|safe|normal)\b',
+            r'\b(should|can|may|might)\s+(i|you|we)\s+(take|use|do|avoid)\b',
+            r'\b(diagnosis|diagnosed|symptoms|treatment|medicine|drug)\b',
+            r'\b(medical|health|doctor|physician|hospital|clinic)\b',
+            r'\b(pain|hurt|ache|sore|fever|cough|headache)\b',
+            r'\b(which\s+medication|best\s+medication|how\s+to\s+cure|without\s+medications)\b',
+            r'\b(chronic\s+migraine|migraine\s+treatment|migraine\s+cure)\b',
+            r'\b(cure|treat|heal|relief|remedy|solution)\b'
+        ]
+        
+        for pattern in medical_patterns:
+            if re.search(pattern, query_lower):
+                return True
+        
+        return False
+
+    def check_user_query(self, user_query: str) -> Tuple[bool, str]:
+        """Validate the user query is safe to process with medical context awareness."""
+        if not self.enabled:
+            logger.info("[SafetyGuard] Safety guard disabled, allowing query through")
+            return True, "guard_disabled"
+            
+        text = user_query or ""
+        
+        # For medical queries, be more permissive
+        if self._is_medical_query(text):
+            logger.info("[SafetyGuard] Medical query detected, skipping strict validation")
+            return True, "medical_query"
+        
+        # If too long, validate each chunk; any UNSAFE makes overall UNSAFE
+        for part in self._chunk_text(text):
+            messages = [{"role": "user", "content": part}]
+            reply = self._call_guard(messages, max_tokens=64)
+            ok, reason = self._parse_guard_reply(reply)
+            if not ok:
+                return False, reason
+        return True, ""
+
+    def _detect_harmful_content(self, text: str) -> Tuple[bool, str]:
+        """Detect harmful content using sophisticated pattern matching."""
+        if not text:
+            return True, ""
+        
+        text_lower = text.lower()
+        
+        # First check if this is clearly medical content - be more permissive
+        if self._is_medical_query(text):
+            # For medical content, only check for truly dangerous patterns
+            dangerous_medical_patterns = {
+                'suicide_self_harm': [
+                    r'\b(kill\s+yourself|suicide|end\s+your\s+life|take\s+your\s+life)\b',
+                    r'\b(self\s*harm|self\s*injury|cut\s+yourself|hurt\s+yourself)\b',
+                    r'\b(overdose|poison\s+yourself|hang\s+yourself)\b'
+                ],
+                'dangerous_medical_advice': [
+                    r'\b(overdose\s+on|take\s+too\s+much|excessive\s+dosage)\b',
+                    r'\b(mix\s+drugs|combine\s+medications|contraindicated)\b',
+                    r'\b(stop\s+taking\s+prescribed|discontinue\s+medication)\b',
+                    r'\b(don\'t\s+call\s+911|avoid\s+emergency\s+room|ignore\s+severe\s+symptoms)\b'
+                ],
+                'illegal_drugs': [
+                    r'\b(cocaine|heroin|methamphetamine|ecstasy|lsd|marijuana\s+abuse)\b',
+                    r'\b(prescription\s+abuse|drug\s+dealing|illegal\s+substances)\b'
+                ]
+            }
+            
+            # Check only dangerous medical patterns
+            for category, patterns in dangerous_medical_patterns.items():
+                for pattern in patterns:
+                    if re.search(pattern, text_lower):
+                        return False, f"contains {category}: {pattern}"
+            
+            # Allow medical content through
+            return True, "medical_content"
+        
+        # For non-medical content, use stricter patterns
+        critical_patterns = {
+            'suicide_self_harm': [
+                r'\b(kill\s+yourself|suicide|end\s+your\s+life|take\s+your\s+life)\b',
+                r'\b(self\s*harm|self\s*injury|cut\s+yourself|hurt\s+yourself)\b',
+                r'\b(overdose|poison\s+yourself|hang\s+yourself)\b'
+            ],
+            'violence': [
+                r'\b(kill\s+someone|murder|assassinate|violence|harm\s+others)\b',
+                r'\b(bomb|explosive|weapon|gun|knife)\b',
+                r'\b(attack\s+(someone|people|others|innocent))\b'  # More specific attack pattern
+            ],
+            'illegal_drugs': [
+                r'\b(cocaine|heroin|methamphetamine|ecstasy|lsd|marijuana\s+abuse)\b',
+                r'\b(prescription\s+abuse|drug\s+dealing|illegal\s+substances)\b'
+            ],
+            'dangerous_medical': [
+                r'\b(overdose\s+on|take\s+too\s+much|excessive\s+dosage)\b',
+                r'\b(mix\s+drugs|combine\s+medications|contraindicated)\b',
+                r'\b(stop\s+taking\s+prescribed|discontinue\s+medication)\b'
+            ]
+        }
+        
+        # Check critical patterns
+        for category, patterns in critical_patterns.items():
+            for pattern in patterns:
+                if re.search(pattern, text_lower):
+                    return False, f"contains {category}: {pattern}"
+        
+        # Context-aware medical safety checks
+        medical_safety_patterns = {
+            'dosage_warnings': [
+                r'\b(take\s+more\s+than\s+prescribed|exceed\s+recommended\s+dose)\b',
+                r'\b(double\s+up\s+on\s+medication|take\s+extra\s+pills)\b'
+            ],
+            'emergency_advice': [
+                r'\b(don\'t\s+call\s+911|avoid\s+emergency\s+room|ignore\s+severe\s+symptoms)\b',
+                r'\b(self\s*treat\s+emergency|handle\s+at\s+home\s+when\s+critical)\b'
+            ]
+        }
+        
+        # Check medical safety patterns
+        for category, patterns in medical_safety_patterns.items():
+            for pattern in patterns:
+                if re.search(pattern, text_lower):
+                    return False, f"contains dangerous medical advice: {pattern}"
+        
+        return True, ""
+
+    def _enhance_messages_with_context(self, messages: List[Dict]) -> List[Dict]:
+        """Enhance messages with medical context awareness for better guard performance."""
+        if not messages:
+            return messages
+        
+        # Check if any message contains medical content
+        has_medical_content = any(
+            self._is_medical_query(msg.get("content", "")) for msg in messages
+        )
+        
+        if has_medical_content:
+            # Add medical context to the system prompt
+            enhanced_messages = []
+            for i, msg in enumerate(messages):
+                if i == 0 and msg.get("role") == "user":
+                    # Add medical context to first user message
+                    original_content = msg.get("content", "")
+                    enhanced_content = f"""MEDICAL CONTEXT: This is a medical consultation. The user is asking about health-related topics.
+
+ORIGINAL MESSAGE: {original_content}
+
+Please evaluate this message for safety, keeping in mind that:
+- Medical questions and health concerns are legitimate
+- General medical information sharing is acceptable
+- Only block content that is clearly harmful, dangerous, or illegal
+- Medical advice should be educational, not prescriptive"""
+                    
+                    enhanced_messages.append({
+                        "role": msg["role"],
+                        "content": enhanced_content
+                    })
+                else:
+                    enhanced_messages.append(msg)
+            return enhanced_messages
+        
+        return messages
+
+    def _assess_risk_level(self, text: str) -> Tuple[str, float]:
+        """Assess the risk level of content using multiple indicators."""
+        if not text:
+            return "low", 0.0
+        
+        text_lower = text.lower()
+        
+        # If this is medical content, be more lenient
+        if self._is_medical_query(text):
+            # For medical content, only flag truly dangerous patterns
+            dangerous_medical_indicators = {
+                'high': [
+                    'suicide', 'kill yourself', 'end your life', 'self harm',
+                    'overdose', 'poison yourself', 'illegal drugs', 'violence'
+                ],
+                'medium': [
+                    'prescription abuse', 'excessive dosage', 'mix drugs',
+                    'stop taking prescribed', 'ignore severe symptoms'
+                ]
+            }
+            
+            risk_score = 0.0
+            for level, indicators in dangerous_medical_indicators.items():
+                for indicator in indicators:
+                    if indicator in text_lower:
+                        if level == 'high':
+                            risk_score += 3.0
+                        elif level == 'medium':
+                            risk_score += 1.5
+            
+            # Normalize score for medical content (more lenient)
+            risk_score = min(risk_score / 15.0, 1.0)
+            
+            if risk_score >= 0.6:
+                return "high", risk_score
+            elif risk_score >= 0.2:
+                return "medium", risk_score
+            else:
+                return "low", risk_score
+        
+        # For non-medical content, use original risk assessment
+        risk_indicators = {
+            'high': [
+                'suicide', 'kill yourself', 'end your life', 'self harm',
+                'overdose', 'poison', 'illegal drugs', 'violence', 'harm others'
+            ],
+            'medium': [
+                'prescription abuse', 'excessive dosage', 'mix drugs',
+                'stop medication', 'ignore symptoms', 'avoid doctor'
+            ],
+            'low': [
+                'pain', 'headache', 'fever', 'cough', 'treatment',
+                'medicine', 'doctor', 'hospital', 'symptoms'
+            ]
+        }
+        
+        risk_score = 0.0
+        for level, indicators in risk_indicators.items():
+            for indicator in indicators:
+                if indicator in text_lower:
+                    if level == 'high':
+                        risk_score += 3.0
+                    elif level == 'medium':
+                        risk_score += 1.5
+                    else:
+                        risk_score += 0.5
+        
+        # Normalize score
+        risk_score = min(risk_score / 10.0, 1.0)
+        
+        if risk_score >= 0.7:
+            return "high", risk_score
+        elif risk_score >= 0.3:
+            return "medium", risk_score
+        else:
+            return "low", risk_score
+
+    def check_model_answer(self, user_query: str, model_answer: str) -> Tuple[bool, str]:
+        """Validate the model's answer is safe with medical context awareness."""
+        if not self.enabled:
+            logger.info("[SafetyGuard] Safety guard disabled, allowing response through")
+            return True, "guard_disabled"
+            
+        uq = user_query or ""
+        ans = model_answer or ""
+        
+        # Assess risk level first
+        risk_level, risk_score = self._assess_risk_level(ans)
+        logger.info(f"[SafetyGuard] Risk assessment: {risk_level} (score: {risk_score:.2f})")
+        
+        # Always check for harmful content first
+        is_safe, reason = self._detect_harmful_content(ans)
+        if not is_safe:
+            return False, reason
+        
+        # For high-risk content, always use strict validation
+        if risk_level == "high":
+            logger.warning("[SafetyGuard] High-risk content detected, using strict validation")
+            user_parts = self._chunk_text(uq, chunk_size=2000)
+            user_context = user_parts[0] if user_parts else ""
+            for ans_part in self._chunk_text(ans):
+                messages = [
+                    {"role": "user", "content": user_context},
+                    {"role": "assistant", "content": ans_part},
+                ]
+                reply = self._call_guard(messages, max_tokens=96)
+                ok, reason = self._parse_guard_reply(reply)
+                if not ok:
+                    return False, reason
+            return True, "high_risk_validated"
+        
+        # For medical queries and answers, use relaxed validation
+        if self._is_medical_query(uq) or self._is_medical_query(ans):
+            logger.info("[SafetyGuard] Medical content detected, using relaxed validation")
+            return True, "medical_content"
+        
+        # For medium-risk non-medical content, use guard validation
+        if risk_level == "medium":
+            logger.info("[SafetyGuard] Medium-risk content detected, using guard validation")
+            user_parts = self._chunk_text(uq, chunk_size=2000)
+            user_context = user_parts[0] if user_parts else ""
+            for ans_part in self._chunk_text(ans):
+                messages = [
+                    {"role": "user", "content": user_context},
+                    {"role": "assistant", "content": ans_part},
+                ]
+                reply = self._call_guard(messages, max_tokens=96)
+                ok, reason = self._parse_guard_reply(reply)
+                if not ok:
+                    return False, reason
+            return True, "medium_risk_validated"
+        
+        # For low-risk content, allow through
+        logger.info("[SafetyGuard] Low-risk content detected, allowing through")
+        return True, "low_risk"
+
+
+# Global instance (optional convenience) - will be initialized with rotator when needed
+safety_guard = None
+
+

src/services/medical_response.py

@@ -3,6 +3,7 @@
 from src.core import prompt_builder
 from src.data.medical_kb import search_medical_kb
 from src.services.gemini import gemini_chat
+from src.services.guard import SafetyGuard
 from src.utils.logger import logger
 from src.utils.rotator import APIKeyRotator
 
@@ -12,7 +13,8 @@ async def generate_medical_response(
 	user_role: str,
 	user_specialty: str,
 	rotator: APIKeyRotator,
-	medical_context: str = ""
+	medical_context: str = "",
+	nvidia_rotator: APIKeyRotator = None
 ) -> str:
 	"""Generates an intelligent, contextual medical response using Gemini AI."""
 	prompt = prompt_builder.medical_response_prompt(user_role, user_specialty, medical_context, user_message)
@@ -25,6 +27,22 @@ async def generate_medical_response(
 		if "disclaimer" not in response_text.lower() and "consult" not in response_text.lower():
 			response_text += "\n\n⚠️ **Important Disclaimer:** This information is for educational purposes only and should not replace professional medical advice, diagnosis, or treatment. Always consult with qualified healthcare professionals."
 
+		# Safety Guard: Validate the generated response
+		if nvidia_rotator:
+			try:
+				safety_guard = SafetyGuard(nvidia_rotator)
+				is_safe, safety_reason = safety_guard.check_model_answer(user_message, response_text)
+				if not is_safe:
+					logger().warning(f"Safety guard blocked generated response: {safety_reason}")
+					# Return safe fallback response
+					return "I apologize, but I cannot provide a response to that query as it may contain unsafe content. Please consult with a qualified healthcare professional for medical advice."
+				else:
+					logger().info(f"Generated response passed safety validation: {safety_reason}")
+			except Exception as e:
+				logger().error(f"Safety guard error in medical response: {e}")
+				# Fail open for now - allow response through if guard fails
+				logger().warning("Safety guard failed, allowing generated response through")
+
 		logger().info(f"Gemini response generated, length: {len(response_text)} chars")
 		return response_text
 

src/services/service.py

@@ -131,7 +131,7 @@ class EMRService:
 
             # Generate embeddings
             combined_text = " | ".join(text_parts)
-            embeddings = await self.embedding_client.generate_embeddings(combined_text)
+            embeddings = self.embedding_client.embed(combined_text)[0]
 
             return embeddings
 
@@ -181,7 +181,7 @@ class EMRService:
         """Search EMR entries using semantic similarity."""
         try:
             # Generate embeddings for the search query
-            query_embeddings = await self.embedding_client.generate_embeddings(query)
+            query_embeddings = self.embedding_client.embed(query)[0]
 
             # Search using semantic similarity
             entries = search_emr_by_semantic_similarity(

static/css/emr.css

@@ -115,6 +115,365 @@
     letter-spacing: 0.05em;
 }
 
+/* File Upload Section */
+.emr-upload-section {
+    background-color: var(--bg-primary);
+    border-bottom: 1px solid var(--border-color);
+    padding: var(--spacing-lg);
+    max-width: 1200px;
+    margin: 0 auto;
+}
+
+.upload-container {
+    max-width: 600px;
+    margin: 0 auto;
+}
+
+.upload-header {
+    text-align: center;
+    margin-bottom: var(--spacing-lg);
+}
+
+.upload-header h3 {
+    margin: 0 0 var(--spacing-sm) 0;
+    color: var(--text-primary);
+    font-size: 1.25rem;
+    font-weight: 600;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: var(--spacing-sm);
+}
+
+.upload-header p {
+    margin: 0;
+    color: var(--text-secondary);
+    font-size: 0.875rem;
+}
+
+.upload-area {
+    border: 2px dashed var(--border-color);
+    border-radius: 12px;
+    padding: var(--spacing-2xl);
+    text-align: center;
+    background-color: var(--bg-secondary);
+    transition: all var(--transition-fast);
+    cursor: pointer;
+}
+
+.upload-area:hover {
+    border-color: var(--primary-color);
+    background-color: var(--bg-tertiary);
+}
+
+.upload-area.dragover {
+    border-color: var(--primary-color);
+    background-color: var(--primary-color);
+    color: white;
+}
+
+.upload-content i {
+    font-size: 3rem;
+    color: var(--primary-color);
+    margin-bottom: var(--spacing-md);
+}
+
+.upload-area.dragover .upload-content i {
+    color: white;
+}
+
+.upload-content h4 {
+    margin: 0 0 var(--spacing-sm) 0;
+    color: var(--text-primary);
+    font-size: 1.125rem;
+    font-weight: 600;
+}
+
+.upload-area.dragover .upload-content h4 {
+    color: white;
+}
+
+.upload-content p {
+    margin: 0 0 var(--spacing-lg) 0;
+    color: var(--text-secondary);
+    font-size: 0.875rem;
+}
+
+.upload-area.dragover .upload-content p {
+    color: white;
+}
+
+.upload-progress {
+    margin-top: var(--spacing-lg);
+}
+
+.progress-bar {
+    width: 100%;
+    height: 8px;
+    background-color: var(--bg-tertiary);
+    border-radius: 4px;
+    overflow: hidden;
+    margin-bottom: var(--spacing-sm);
+}
+
+.progress-fill {
+    height: 100%;
+    background-color: var(--primary-color);
+    transition: width var(--transition-normal);
+    width: 0%;
+}
+
+.progress-text {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    text-align: center;
+    display: block;
+}
+
+/* Document Preview Modal */
+.document-preview-modal {
+    max-width: 900px;
+    max-height: 85vh;
+    overflow-y: auto;
+}
+
+.document-preview-section {
+    margin-bottom: var(--spacing-lg);
+    background-color: var(--bg-secondary);
+    border-radius: 8px;
+    padding: var(--spacing-md);
+    border: 1px solid var(--border-color);
+}
+
+.document-preview-section h4 {
+    margin: 0 0 var(--spacing-md) 0;
+    color: var(--text-primary);
+    font-size: 1rem;
+    font-weight: 600;
+    border-bottom: 1px solid var(--border-color);
+    padding-bottom: var(--spacing-sm);
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-sm);
+}
+
+.document-preview-section h4 i {
+    color: var(--primary-color);
+}
+
+.editable-field {
+    background-color: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: var(--spacing-sm);
+    margin-bottom: var(--spacing-sm);
+    min-height: 40px;
+    transition: border-color var(--transition-fast);
+}
+
+.editable-field:focus {
+    outline: none;
+    border-color: var(--primary-color);
+    box-shadow: 0 0 0 3px rgb(37 99 235 / 0.1);
+}
+
+.editable-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+}
+
+.editable-list li {
+    background-color: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: var(--spacing-sm);
+    margin-bottom: var(--spacing-sm);
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-sm);
+}
+
+.editable-list li input {
+    flex: 1;
+    background: none;
+    border: none;
+    outline: none;
+    color: var(--text-primary);
+    font-size: 0.875rem;
+}
+
+.editable-list li button {
+    background: none;
+    border: none;
+    color: var(--accent-color);
+    cursor: pointer;
+    padding: var(--spacing-xs);
+    border-radius: 4px;
+    transition: background-color var(--transition-fast);
+}
+
+.editable-list li button:hover {
+    background-color: var(--bg-tertiary);
+}
+
+.add-item-btn {
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    border-radius: 6px;
+    padding: var(--spacing-sm) var(--spacing-md);
+    cursor: pointer;
+    font-size: 0.875rem;
+    transition: background-color var(--transition-fast);
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-xs);
+}
+
+.add-item-btn:hover {
+    background-color: var(--primary-hover);
+}
+
+.medication-preview-item {
+    background-color: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    padding: var(--spacing-md);
+    margin-bottom: var(--spacing-sm);
+}
+
+.medication-preview-item h5 {
+    margin: 0 0 var(--spacing-sm) 0;
+    color: var(--text-primary);
+    font-size: 1rem;
+    font-weight: 600;
+}
+
+.medication-detail-row {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: var(--spacing-md);
+    margin-bottom: var(--spacing-sm);
+}
+
+.medication-detail-row:last-child {
+    margin-bottom: 0;
+}
+
+.medication-detail-row label {
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: var(--spacing-xs);
+    display: block;
+}
+
+.medication-detail-row input {
+    width: 100%;
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    padding: var(--spacing-sm);
+    color: var(--text-primary);
+    font-size: 0.875rem;
+}
+
+.medication-detail-row input:focus {
+    outline: none;
+    border-color: var(--primary-color);
+}
+
+.vital-signs-preview-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+    gap: var(--spacing-md);
+}
+
+.vital-sign-preview-item {
+    background-color: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    padding: var(--spacing-md);
+    text-align: center;
+}
+
+.vital-sign-preview-item label {
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: var(--spacing-xs);
+    display: block;
+}
+
+.vital-sign-preview-item input {
+    width: 100%;
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    padding: var(--spacing-sm);
+    color: var(--text-primary);
+    font-size: 0.875rem;
+    text-align: center;
+}
+
+.vital-sign-preview-item input:focus {
+    outline: none;
+    border-color: var(--primary-color);
+}
+
+.lab-result-preview-item {
+    background-color: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    padding: var(--spacing-md);
+    margin-bottom: var(--spacing-sm);
+}
+
+.lab-result-preview-item h5 {
+    margin: 0 0 var(--spacing-sm) 0;
+    color: var(--text-primary);
+    font-size: 1rem;
+    font-weight: 600;
+}
+
+.lab-result-detail-row {
+    display: grid;
+    grid-template-columns: 1fr 1fr 1fr;
+    gap: var(--spacing-md);
+    margin-bottom: var(--spacing-sm);
+}
+
+.lab-result-detail-row:last-child {
+    margin-bottom: 0;
+}
+
+.lab-result-detail-row label {
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: var(--spacing-xs);
+    display: block;
+}
+
+.lab-result-detail-row input {
+    width: 100%;
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: 4px;
+    padding: var(--spacing-sm);
+    color: var(--text-primary);
+    font-size: 0.875rem;
+}
+
+.lab-result-detail-row input:focus {
+    outline: none;
+    border-color: var(--primary-color);
+}
+
 /* Controls */
 .emr-controls {
     background-color: var(--bg-primary);
@@ -531,4 +890,291 @@
     .emr-table tbody tr:hover {
         background-color: var(--dark-bg-secondary);
     }
+}
+
+/* Tabbed Interface */
+.emr-tabs {
+    display: flex;
+    background-color: var(--bg-primary);
+    border-bottom: 1px solid var(--border-color);
+    margin-bottom: var(--spacing-lg);
+    border-radius: 8px 8px 0 0;
+    overflow-x: auto;
+}
+
+.tab-btn {
+    background: none;
+    border: none;
+    padding: var(--spacing-md) var(--spacing-lg);
+    cursor: pointer;
+    color: var(--text-secondary);
+    font-weight: 500;
+    transition: all var(--transition-fast);
+    border-bottom: 3px solid transparent;
+    white-space: nowrap;
+    min-width: 120px;
+    text-align: center;
+}
+
+.tab-btn:hover {
+    color: var(--primary-color);
+    background-color: var(--bg-secondary);
+}
+
+.tab-btn.active {
+    color: var(--primary-color);
+    border-bottom-color: var(--primary-color);
+    background-color: var(--bg-secondary);
+}
+
+.tab-content {
+    display: none;
+    animation: fadeIn 0.3s ease-in-out;
+}
+
+.tab-content.active {
+    display: block;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+/* EMR Sections */
+.emr-section {
+    background-color: var(--bg-primary);
+    border-radius: 8px;
+    padding: var(--spacing-lg);
+    margin-bottom: var(--spacing-lg);
+    box-shadow: var(--shadow-sm);
+}
+
+.emr-section h3 {
+    margin: 0 0 var(--spacing-lg) 0;
+    color: var(--text-primary);
+    font-size: 1.25rem;
+    font-weight: 600;
+    border-bottom: 2px solid var(--primary-color);
+    padding-bottom: var(--spacing-sm);
+}
+
+/* Diagnosis Timeline */
+.diagnosis-timeline {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-md);
+}
+
+.diagnosis-item {
+    display: flex;
+    align-items: center;
+    padding: var(--spacing-md);
+    background-color: var(--bg-secondary);
+    border-radius: 8px;
+    border-left: 4px solid var(--primary-color);
+    transition: all var(--transition-fast);
+}
+
+.diagnosis-item:hover {
+    background-color: var(--bg-tertiary);
+    transform: translateX(4px);
+}
+
+.diagnosis-date {
+    font-size: 0.875rem;
+    color: var(--text-muted);
+    min-width: 120px;
+    margin-right: var(--spacing-md);
+}
+
+.diagnosis-name {
+    font-weight: 600;
+    color: var(--text-primary);
+    flex: 1;
+}
+
+.diagnosis-confidence {
+    background-color: var(--primary-color);
+    color: white;
+    padding: var(--spacing-xs) var(--spacing-sm);
+    border-radius: 12px;
+    font-size: 0.75rem;
+    font-weight: 600;
+}
+
+/* Medications Grid */
+.medications-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: var(--spacing-md);
+}
+
+.medication-card {
+    background-color: var(--bg-secondary);
+    border-radius: 8px;
+    padding: var(--spacing-md);
+    border: 1px solid var(--border-color);
+    transition: all var(--transition-fast);
+}
+
+.medication-card:hover {
+    border-color: var(--primary-color);
+    box-shadow: var(--shadow-md);
+}
+
+.medication-name {
+    font-weight: 600;
+    color: var(--text-primary);
+    margin-bottom: var(--spacing-sm);
+    font-size: 1.1rem;
+}
+
+.medication-details {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-xs);
+    color: var(--text-secondary);
+    font-size: 0.875rem;
+}
+
+.medication-detail {
+    display: flex;
+    justify-content: space-between;
+}
+
+.medication-detail strong {
+    color: var(--text-primary);
+}
+
+/* Vital Signs Chart */
+.vitals-chart-container {
+    background-color: var(--bg-secondary);
+    border-radius: 8px;
+    padding: var(--spacing-lg);
+    margin-bottom: var(--spacing-lg);
+    text-align: center;
+}
+
+.vitals-chart-container canvas {
+    max-width: 100%;
+    height: auto;
+}
+
+/* Vital Signs Table */
+.vitals-table-container {
+    overflow-x: auto;
+}
+
+.vitals-table {
+    width: 100%;
+    border-collapse: collapse;
+    background-color: var(--bg-primary);
+    border-radius: 8px;
+    overflow: hidden;
+    box-shadow: var(--shadow-sm);
+}
+
+.vitals-table th,
+.vitals-table td {
+    padding: var(--spacing-md);
+    text-align: left;
+    border-bottom: 1px solid var(--border-color);
+}
+
+.vitals-table th {
+    background-color: var(--bg-tertiary);
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.vitals-table td {
+    color: var(--text-secondary);
+}
+
+.vitals-table tr:hover {
+    background-color: var(--bg-secondary);
+}
+
+/* Lab Results */
+.lab-results-container {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-md);
+}
+
+.lab-result-item {
+    background-color: var(--bg-secondary);
+    border-radius: 8px;
+    padding: var(--spacing-md);
+    border-left: 4px solid var(--secondary-color);
+}
+
+.lab-result-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: var(--spacing-sm);
+}
+
+.lab-test-name {
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.lab-test-value {
+    font-size: 1.1rem;
+    font-weight: 600;
+    color: var(--secondary-color);
+}
+
+.lab-test-details {
+    display: flex;
+    gap: var(--spacing-md);
+    color: var(--text-secondary);
+    font-size: 0.875rem;
+}
+
+/* Procedures Timeline */
+.procedures-timeline {
+    display: flex;
+    flex-direction: column;
+    gap: var(--spacing-md);
+}
+
+.procedure-item {
+    display: flex;
+    align-items: center;
+    padding: var(--spacing-md);
+    background-color: var(--bg-secondary);
+    border-radius: 8px;
+    border-left: 4px solid var(--accent-color);
+    transition: all var(--transition-fast);
+}
+
+.procedure-item:hover {
+    background-color: var(--bg-tertiary);
+    transform: translateX(4px);
+}
+
+.procedure-date {
+    font-size: 0.875rem;
+    color: var(--text-muted);
+    min-width: 120px;
+    margin-right: var(--spacing-md);
+}
+
+.procedure-name {
+    font-weight: 600;
+    color: var(--text-primary);
+    flex: 1;
+}
+
+.procedure-status {
+    background-color: var(--accent-color);
+    color: white;
+    padding: var(--spacing-xs) var(--spacing-sm);
+    border-radius: 12px;
+    font-size: 0.75rem;
+    font-weight: 600;
 }

static/css/styles.css

@@ -456,9 +456,122 @@ body {
     border-color: var(--primary-color);
 }
 
-.message-text h3 {
-    margin-bottom: var(--spacing-md);
-    color: inherit;
+/* Tagged Title Styling */
+.tagged-title {
+    display: flex;
+    align-items: center;
+    margin: var(--spacing-lg) 0;
+    position: relative;
+    width: 100%;
+}
+
+.tagged-title-bar {
+    width: 4px;
+    height: 100%;
+    background-color: #20b2aa; /* Teal/green color */
+    border-radius: 2px;
+    margin-right: 0;
+    flex-shrink: 0;
+    min-height: 40px;
+}
+
+.tagged-title-content {
+    flex: 1;
+    background-color: #f5f5f5; /* Light gray background */
+    border-radius: 0 8px 8px 0;
+    padding: var(--spacing-md) var(--spacing-lg);
+    margin-left: 0;
+    display: flex;
+    align-items: center;
+    min-height: 40px;
+}
+
+.tagged-title-content h1,
+.tagged-title-content h2,
+.tagged-title-content h3,
+.tagged-title-content h4,
+.tagged-title-content h5,
+.tagged-title-content h6 {
+    margin: 0;
+    color: #8b4513; /* Dark brown/maroon color */
+    font-weight: 700;
+    text-transform: uppercase;
+    font-size: 0.9rem;
+    letter-spacing: 0.5px;
+}
+
+/* Blue Bubble Styling */
+.blue-bubble {
+    display: inline-block;
+    background-color: #4a90e2; /* Medium blue */
+    color: white;
+    padding: 4px 8px;
+    border-radius: 12px;
+    font-size: 0.85rem;
+    font-weight: 500;
+    margin: 0 2px;
+    white-space: nowrap;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    line-height: 1.2;
+    vertical-align: baseline;
+}
+
+/* Dark theme adjustments */
+[data-theme="dark"] .tagged-title-content {
+    background-color: #2a2a2a; /* Darker gray for dark theme */
+}
+
+[data-theme="dark"] .tagged-title-content h1,
+[data-theme="dark"] .tagged-title-content h2,
+[data-theme="dark"] .tagged-title-content h3,
+[data-theme="dark"] .tagged-title-content h4,
+[data-theme="dark"] .tagged-title-content h5,
+[data-theme="dark"] .tagged-title-content h6 {
+    color: #d4a574; /* Lighter brown for dark theme */
+}
+
+[data-theme="dark"] .blue-bubble {
+    background-color: #5ba0f2; /* Slightly lighter blue for dark theme */
+}
+
+/* Ensure proper spacing and layout within message content */
+.message-text .tagged-title {
+    margin: var(--spacing-md) 0;
+}
+
+.message-text .tagged-title:first-child {
+    margin-top: 0;
+}
+
+.message-text .tagged-title:last-child {
+    margin-bottom: 0;
+}
+
+/* Ensure blue bubbles work well within paragraphs */
+.message-text p .blue-bubble {
+    margin: 0 4px;
+}
+
+/* Responsive adjustments for smaller screens */
+@media (max-width: 768px) {
+    .tagged-title-content {
+        padding: var(--spacing-sm) var(--spacing-md);
+        min-height: 36px;
+    }
+    
+    .tagged-title-content h1,
+    .tagged-title-content h2,
+    .tagged-title-content h3,
+    .tagged-title-content h4,
+    .tagged-title-content h5,
+    .tagged-title-content h6 {
+        font-size: 0.8rem;
+    }
+    
+    .blue-bubble {
+        font-size: 0.8rem;
+        padding: 3px 6px;
+    }
 }
 
 .message-text p {

static/emr.html

@@ -51,6 +51,34 @@
             </div>
         </div>
 
+        <!-- File Upload Section -->
+        <div class="emr-upload-section">
+            <div class="upload-container">
+                <div class="upload-header">
+                    <h3><i class="fas fa-upload"></i> Upload Medical Document</h3>
+                    <p>Upload PDF, image, or document files to extract medical information</p>
+                </div>
+                <div class="upload-area" id="uploadArea">
+                    <div class="upload-content">
+                        <i class="fas fa-cloud-upload-alt"></i>
+                        <h4>Drop files here or click to browse</h4>
+                        <p>Supported formats: PDF, DOC, DOCX, JPG, PNG, TIFF</p>
+                        <input type="file" id="fileInput" accept=".pdf,.doc,.docx,.jpg,.jpeg,.png,.tiff" multiple style="display: none;">
+                        <button class="btn btn-primary" id="uploadBtn">
+                            <i class="fas fa-folder-open"></i>
+                            Choose Files
+                        </button>
+                    </div>
+                </div>
+                <div class="upload-progress" id="uploadProgress" style="display: none;">
+                    <div class="progress-bar">
+                        <div class="progress-fill" id="progressFill"></div>
+                    </div>
+                    <span class="progress-text" id="progressText">Uploading...</span>
+                </div>
+            </div>
+        </div>
+
         <!-- Search and Filters -->
         <div class="emr-controls">
             <div class="search-container">
@@ -76,27 +104,107 @@
             </div>
         </div>
 
-        <!-- EMR Entries Table -->
+        <!-- EMR Content Tabs -->
         <div class="emr-content">
-            <div class="emr-table-container">
-                <table class="emr-table" id="emrTable">
-                    <thead>
-                        <tr>
-                            <th>Date & Time</th>
-                            <th>Type</th>
-                            <th>Diagnosis</th>
-                            <th>Medications</th>
-                            <th>Vital Signs</th>
-                            <th>Confidence</th>
-                            <th>Actions</th>
-                        </tr>
-                    </thead>
-                    <tbody id="emrTableBody">
-                        <!-- EMR entries will be populated here -->
-                    </tbody>
-                </table>
+            <div class="emr-tabs">
+                <button class="tab-btn active" data-tab="overview">Overview</button>
+                <button class="tab-btn" data-tab="diagnosis">Diagnoses</button>
+                <button class="tab-btn" data-tab="medications">Medications</button>
+                <button class="tab-btn" data-tab="vitals">Vital Signs</button>
+                <button class="tab-btn" data-tab="lab">Lab Results</button>
+                <button class="tab-btn" data-tab="procedures">Procedures</button>
+            </div>
+
+            <!-- Overview Tab -->
+            <div class="tab-content active" id="overview-tab">
+                <div class="emr-table-container">
+                    <table class="emr-table" id="emrTable">
+                        <thead>
+                            <tr>
+                                <th>Date & Time</th>
+                                <th>Type</th>
+                                <th>Diagnosis</th>
+                                <th>Medications</th>
+                                <th>Vital Signs</th>
+                                <th>Confidence</th>
+                                <th>Actions</th>
+                            </tr>
+                        </thead>
+                        <tbody id="emrTableBody">
+                            <!-- EMR entries will be populated here -->
+                        </tbody>
+                    </table>
+                </div>
             </div>
 
+            <!-- Diagnosis Tab -->
+            <div class="tab-content" id="diagnosis-tab">
+                <div class="emr-section">
+                    <h3>Diagnosis History</h3>
+                    <div class="diagnosis-timeline" id="diagnosisTimeline">
+                        <!-- Diagnosis entries will be populated here -->
+                    </div>
+                </div>
+            </div>
+
+            <!-- Medications Tab -->
+            <div class="tab-content" id="medications-tab">
+                <div class="emr-section">
+                    <h3>Medication History</h3>
+                    <div class="medications-grid" id="medicationsGrid">
+                        <!-- Medication entries will be populated here -->
+                    </div>
+                </div>
+            </div>
+
+            <!-- Vital Signs Tab -->
+            <div class="tab-content" id="vitals-tab">
+                <div class="emr-section">
+                    <h3>Vital Signs Trends</h3>
+                    <div class="vitals-chart-container">
+                        <canvas id="vitalsChart" width="800" height="400"></canvas>
+                    </div>
+                    <div class="vitals-table-container">
+                        <table class="vitals-table" id="vitalsTable">
+                            <thead>
+                                <tr>
+                                    <th>Date</th>
+                                    <th>Blood Pressure</th>
+                                    <th>Heart Rate</th>
+                                    <th>Temperature</th>
+                                    <th>Respiratory Rate</th>
+                                    <th>Oxygen Saturation</th>
+                                </tr>
+                            </thead>
+                            <tbody id="vitalsTableBody">
+                                <!-- Vital signs entries will be populated here -->
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Lab Results Tab -->
+            <div class="tab-content" id="lab-tab">
+                <div class="emr-section">
+                    <h3>Laboratory Results</h3>
+                    <div class="lab-results-container" id="labResultsContainer">
+                        <!-- Lab results will be populated here -->
+                    </div>
+                </div>
+            </div>
+
+            <!-- Procedures Tab -->
+            <div class="tab-content" id="procedures-tab">
+                <div class="emr-section">
+                    <h3>Medical Procedures</h3>
+                    <div class="procedures-timeline" id="proceduresTimeline">
+                        <!-- Procedure entries will be populated here -->
+                    </div>
+                </div>
+            </div>
+        </div>
+
             <!-- Loading State -->
             <div class="loading-state" id="loadingState" style="display: none;">
                 <div class="loading-spinner">
@@ -159,6 +267,23 @@
                 </div>
             </div>
         </div>
+
+        <!-- Document Analysis Preview Modal -->
+        <div class="modal" id="documentPreviewModal">
+            <div class="modal-content document-preview-modal">
+                <div class="modal-header">
+                    <h3><i class="fas fa-file-medical"></i> Document Analysis Preview</h3>
+                    <button class="modal-close" id="documentPreviewModalClose">&times;</button>
+                </div>
+                <div class="modal-body" id="documentPreviewContent">
+                    <!-- Document analysis results will be populated here -->
+                </div>
+                <div class="modal-footer">
+                    <button class="btn btn-secondary" id="documentPreviewCancel">Cancel</button>
+                    <button class="btn btn-primary" id="saveDocumentAnalysis">Save to EMR</button>
+                </div>
+            </div>
+        </div>
     </div>
 
     <script src="/static/js/emr.js"></script>

static/index.html

@@ -93,16 +93,25 @@
 					</div>
 					<div class="message-content">
 						<div class="message-text">
-							<h3>👋 Welcome to Medical AI Assistant</h3>
+							👋 Welcome to Medical AI Assistant
+
+							<div class="tagged-title">
+								<div class="tagged-title-bar"></div>
+								<div class="tagged-title-content">
+									<h1>Who am I, and what can I do?</h1>
+								</div>
+							</div>
 							<p>I'm here to help you with medical questions, diagnosis assistance, and healthcare information. I can:</p>
-							<ul>
-								<li>🔍 Answer medical questions and provide information</li>
-								<li>📋 Help with symptom analysis and differential diagnosis</li>
-								<li>💊 Provide medication and treatment information</li>
-								<li>📚 Explain medical procedures and conditions</li>
-								<li>⚠️ Offer general health advice (not medical diagnosis)</li>
-							</ul>
-							<p><strong>Important:</strong> This is for informational purposes only. Always consult with qualified healthcare professionals for medical advice.</p>
+							<div class="tagged-title">
+								<div class="tagged-title-bar"></div>
+								<div class="tagged-title-content">
+									<h1>Key Features</h1>
+								</div>
+							</div>
+							<p><span class="blue-bubble">Medical Information:</span> I can provide evidence-based medical information and explanations.</p>
+							<p><span class="blue-bubble">Symptom Analysis:</span> I can help analyze symptoms and suggest possible conditions.</p>
+							<p><span class="blue-bubble">Treatment Guidance:</span> I can explain treatments, medications, and procedures.</p>
+							<p><span class="blue-bubble">Important:</span> This is for informational purposes only. Always consult with qualified healthcare professionals for medical advice.</p>
 							<p>How can I assist you today?</p>
 						</div>
 						<div class="message-time">Just now</div>

static/js/app.js

@@ -401,13 +401,27 @@ class MedicalChatbotApp {
 
     getWelcomeMessage() {
         return `👋 Welcome to Medical AI Assistant
+
+# Who am I, and what can I do?
+
 I'm here to help you with medical questions, diagnosis assistance, and healthcare information. I can:
+
 🔍 Answer medical questions and provide information
 📋 Help with symptom analysis and differential diagnosis
 💊 Provide medication and treatment information
 📚 Explain medical procedures and conditions
 ⚠️ Offer general health advice (not medical diagnosis)
+
+# Key Features
+
+**Medical Information:** I can provide evidence-based medical information and explanations.
+
+**Symptom Analysis:** I can help analyze symptoms and suggest possible conditions.
+
+**Treatment Guidance:** I can explain treatments, medications, and procedures.
+
 **Important:** This is for informational purposes only. Always consult with qualified healthcare professionals for medical advice.
+
 How can I assist you today?`;
     }
 
@@ -1280,6 +1294,12 @@ How can I assist you today?`;
     }
 
     updatePatientDisplay(patientId, patientName = null) {
+        // Safety check: don't update display if patientId is undefined or null
+        if (!patientId || patientId === 'undefined' || patientId === 'null') {
+            console.warn('updatePatientDisplay called with invalid patientId:', patientId);
+            return;
+        }
+
         const status = document.getElementById('patientStatus');
         const actions = document.getElementById('patientActions');
         const emrLink = document.getElementById('emrLink');
@@ -1860,15 +1880,20 @@ How can I assist you today?`;
 
     formatMessageContent(content) {
         return content
-            // Handle headers (1-6 # symbols)
+            // Handle headers (1-6 # symbols) - create tagged titles
             .replace(/^#{1,6}\s+(.+)$/gm, (match, text, offset, string) => {
                 const level = match.match(/^#+/)[0].length;
-                return `<h${level}>${text}</h${level}>`;
+                return `<div class="tagged-title">
+                    <div class="tagged-title-bar"></div>
+                    <div class="tagged-title-content">
+                        <h${level}>${text}</h${level}>
+                    </div>
+                </div>`;
             })
-            // Handle bold text
-            .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
-            // Handle italic text
-            .replace(/\*(.*?)\*/g, '<em>$1</em>')
+            // Handle bold text - create blue bubbles (improved regex to handle edge cases)
+            .replace(/\*\*([^*]+)\*\*/g, '<span class="blue-bubble">$1</span>')
+            // Handle italic text (only if not already processed as bold)
+            .replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, '<em>$1</em>')
             // Handle line breaks
             .replace(/\n/g, '<br>')
             // Handle emojis with colors

static/js/emr.js

@@ -49,8 +49,18 @@ class EMRPage {
             this.applyFilters();
         });
 
+        // Tab buttons
+        document.querySelectorAll('.tab-btn').forEach(btn => {
+            btn.addEventListener('click', (e) => {
+                this.switchTab(e.target.dataset.tab);
+            });
+        });
+
         // Modal handlers
         this.setupModalHandlers();
+        
+        // File upload handlers
+        this.setupFileUploadHandlers();
     }
 
     setupModalHandlers() {
@@ -95,21 +105,100 @@ class EMRPage {
                 searchModal.classList.remove('show');
             });
         }
+
+        // Document Preview Modal
+        const documentPreviewModal = document.getElementById('documentPreviewModal');
+        const documentPreviewModalClose = document.getElementById('documentPreviewModalClose');
+        const documentPreviewCancel = document.getElementById('documentPreviewCancel');
+        const saveDocumentAnalysis = document.getElementById('saveDocumentAnalysis');
+
+        if (documentPreviewModalClose) {
+            documentPreviewModalClose.addEventListener('click', () => {
+                documentPreviewModal.classList.remove('show');
+            });
+        }
+
+        if (documentPreviewCancel) {
+            documentPreviewCancel.addEventListener('click', () => {
+                documentPreviewModal.classList.remove('show');
+            });
+        }
+
+        if (saveDocumentAnalysis) {
+            saveDocumentAnalysis.addEventListener('click', () => {
+                this.saveDocumentAnalysis();
+            });
+        }
+    }
+
+    setupFileUploadHandlers() {
+        const uploadArea = document.getElementById('uploadArea');
+        const fileInput = document.getElementById('fileInput');
+        const uploadBtn = document.getElementById('uploadBtn');
+        const uploadProgress = document.getElementById('uploadProgress');
+
+        // Click to upload
+        if (uploadBtn) {
+            uploadBtn.addEventListener('click', () => {
+                fileInput.click();
+            });
+        }
+
+        if (uploadArea) {
+            uploadArea.addEventListener('click', () => {
+                fileInput.click();
+            });
+        }
+
+        // File input change
+        if (fileInput) {
+            fileInput.addEventListener('change', (e) => {
+                if (e.target.files.length > 0) {
+                    this.handleFileUpload(e.target.files);
+                }
+            });
+        }
+
+        // Drag and drop
+        if (uploadArea) {
+            uploadArea.addEventListener('dragover', (e) => {
+                e.preventDefault();
+                uploadArea.classList.add('dragover');
+            });
+
+            uploadArea.addEventListener('dragleave', (e) => {
+                e.preventDefault();
+                uploadArea.classList.remove('dragover');
+            });
+
+            uploadArea.addEventListener('drop', (e) => {
+                e.preventDefault();
+                uploadArea.classList.remove('dragover');
+                
+                if (e.dataTransfer.files.length > 0) {
+                    this.handleFileUpload(e.dataTransfer.files);
+                }
+            });
+        }
     }
 
     async loadPatientFromURL() {
         const urlParams = new URLSearchParams(window.location.search);
         const patientId = urlParams.get('patient_id');
 
-        if (patientId) {
+        // Check if patientId is valid (not undefined, null, or empty)
+        if (patientId && patientId !== 'undefined' && patientId !== 'null' && patientId.trim() !== '') {
             this.currentPatientId = patientId;
             await this.loadPatientInfo();
         } else {
             // Try to get from localStorage
             const savedPatientId = localStorage.getItem('medicalChatbotPatientId');
-            if (savedPatientId) {
+            if (savedPatientId && savedPatientId !== 'undefined' && savedPatientId !== 'null' && savedPatientId.trim() !== '') {
                 this.currentPatientId = savedPatientId;
                 await this.loadPatientInfo();
+            } else {
+                console.warn('No valid patient ID found in URL or localStorage');
+                this.showEmptyState();
             }
         }
     }
@@ -556,6 +645,650 @@ class EMRPage {
         emptyState.style.display = 'block';
         tableContainer.style.display = 'none';
     }
+
+    switchTab(tabName) {
+        // Update tab buttons
+        document.querySelectorAll('.tab-btn').forEach(btn => {
+            btn.classList.remove('active');
+        });
+        document.querySelector(`[data-tab="${tabName}"]`).classList.add('active');
+
+        // Update tab content
+        document.querySelectorAll('.tab-content').forEach(content => {
+            content.classList.remove('active');
+        });
+        document.getElementById(`${tabName}-tab`).classList.add('active');
+
+        // Load specific tab data
+        switch (tabName) {
+            case 'diagnosis':
+                this.renderDiagnosisTab();
+                break;
+            case 'medications':
+                this.renderMedicationsTab();
+                break;
+            case 'vitals':
+                this.renderVitalsTab();
+                break;
+            case 'lab':
+                this.renderLabTab();
+                break;
+            case 'procedures':
+                this.renderProceduresTab();
+                break;
+        }
+    }
+
+    renderDiagnosisTab() {
+        const timeline = document.getElementById('diagnosisTimeline');
+        const diagnoses = [];
+
+        this.emrEntries.forEach(entry => {
+            if (entry.extracted_data.diagnosis && entry.extracted_data.diagnosis.length > 0) {
+                entry.extracted_data.diagnosis.forEach(diagnosis => {
+                    diagnoses.push({
+                        name: diagnosis,
+                        date: new Date(entry.created_at).toLocaleDateString(),
+                        confidence: Math.round(entry.confidence_score * 100)
+                    });
+                });
+            }
+        });
+
+        if (diagnoses.length === 0) {
+            timeline.innerHTML = '<p class="no-data">No diagnoses found in EMR entries.</p>';
+            return;
+        }
+
+        timeline.innerHTML = diagnoses.map(diagnosis => `
+            <div class="diagnosis-item">
+                <div class="diagnosis-date">${diagnosis.date}</div>
+                <div class="diagnosis-name">${diagnosis.name}</div>
+                <div class="diagnosis-confidence">${diagnosis.confidence}%</div>
+            </div>
+        `).join('');
+    }
+
+    renderMedicationsTab() {
+        const grid = document.getElementById('medicationsGrid');
+        const medications = [];
+
+        this.emrEntries.forEach(entry => {
+            if (entry.extracted_data.medications && entry.extracted_data.medications.length > 0) {
+                entry.extracted_data.medications.forEach(med => {
+                    medications.push({
+                        name: med.name,
+                        dosage: med.dosage || 'Not specified',
+                        frequency: med.frequency || 'Not specified',
+                        duration: med.duration || 'Not specified',
+                        date: new Date(entry.created_at).toLocaleDateString()
+                    });
+                });
+            }
+        });
+
+        if (medications.length === 0) {
+            grid.innerHTML = '<p class="no-data">No medications found in EMR entries.</p>';
+            return;
+        }
+
+        grid.innerHTML = medications.map(med => `
+            <div class="medication-card">
+                <div class="medication-name">${med.name}</div>
+                <div class="medication-details">
+                    <div class="medication-detail">
+                        <strong>Dosage:</strong> <span>${med.dosage}</span>
+                    </div>
+                    <div class="medication-detail">
+                        <strong>Frequency:</strong> <span>${med.frequency}</span>
+                    </div>
+                    <div class="medication-detail">
+                        <strong>Duration:</strong> <span>${med.duration}</span>
+                    </div>
+                    <div class="medication-detail">
+                        <strong>Date:</strong> <span>${med.date}</span>
+                    </div>
+                </div>
+            </div>
+        `).join('');
+    }
+
+    renderVitalsTab() {
+        const tableBody = document.getElementById('vitalsTableBody');
+        const vitalsData = [];
+
+        this.emrEntries.forEach(entry => {
+            if (entry.extracted_data.vital_signs) {
+                const vitals = entry.extracted_data.vital_signs;
+                if (Object.values(vitals).some(v => v)) {
+                    vitalsData.push({
+                        date: new Date(entry.created_at).toLocaleDateString(),
+                        blood_pressure: vitals.blood_pressure || '-',
+                        heart_rate: vitals.heart_rate || '-',
+                        temperature: vitals.temperature || '-',
+                        respiratory_rate: vitals.respiratory_rate || '-',
+                        oxygen_saturation: vitals.oxygen_saturation || '-'
+                    });
+                }
+            }
+        });
+
+        if (vitalsData.length === 0) {
+            tableBody.innerHTML = '<tr><td colspan="6" class="no-data">No vital signs found in EMR entries.</td></tr>';
+            return;
+        }
+
+        tableBody.innerHTML = vitalsData.map(vitals => `
+            <tr>
+                <td>${vitals.date}</td>
+                <td>${vitals.blood_pressure}</td>
+                <td>${vitals.heart_rate}</td>
+                <td>${vitals.temperature}</td>
+                <td>${vitals.respiratory_rate}</td>
+                <td>${vitals.oxygen_saturation}</td>
+            </tr>
+        `).join('');
+    }
+
+    renderLabTab() {
+        const container = document.getElementById('labResultsContainer');
+        const labResults = [];
+
+        this.emrEntries.forEach(entry => {
+            if (entry.extracted_data.lab_results && entry.extracted_data.lab_results.length > 0) {
+                entry.extracted_data.lab_results.forEach(lab => {
+                    labResults.push({
+                        test_name: lab.test_name,
+                        value: lab.value,
+                        unit: lab.unit || '',
+                        reference_range: lab.reference_range || 'Not specified',
+                        date: new Date(entry.created_at).toLocaleDateString()
+                    });
+                });
+            }
+        });
+
+        if (labResults.length === 0) {
+            container.innerHTML = '<p class="no-data">No lab results found in EMR entries.</p>';
+            return;
+        }
+
+        container.innerHTML = labResults.map(lab => `
+            <div class="lab-result-item">
+                <div class="lab-result-header">
+                    <div class="lab-test-name">${lab.test_name}</div>
+                    <div class="lab-test-value">${lab.value} ${lab.unit}</div>
+                </div>
+                <div class="lab-test-details">
+                    <span><strong>Date:</strong> ${lab.date}</span>
+                    <span><strong>Reference Range:</strong> ${lab.reference_range}</span>
+                </div>
+            </div>
+        `).join('');
+    }
+
+    renderProceduresTab() {
+        const timeline = document.getElementById('proceduresTimeline');
+        const procedures = [];
+
+        this.emrEntries.forEach(entry => {
+            if (entry.extracted_data.procedures && entry.extracted_data.procedures.length > 0) {
+                entry.extracted_data.procedures.forEach(procedure => {
+                    procedures.push({
+                        name: procedure,
+                        date: new Date(entry.created_at).toLocaleDateString(),
+                        confidence: Math.round(entry.confidence_score * 100)
+                    });
+                });
+            }
+        });
+
+        if (procedures.length === 0) {
+            timeline.innerHTML = '<p class="no-data">No procedures found in EMR entries.</p>';
+            return;
+        }
+
+        timeline.innerHTML = procedures.map(procedure => `
+            <div class="procedure-item">
+                <div class="procedure-date">${procedure.date}</div>
+                <div class="procedure-name">${procedure.name}</div>
+                <div class="procedure-status">${procedure.confidence}%</div>
+            </div>
+        `).join('');
+    }
+
+    async handleFileUpload(files) {
+        if (!this.currentPatientId) {
+            alert('Please select a patient first');
+            return;
+        }
+
+        const file = files[0]; // Handle only the first file for now
+        
+        // Validate file type
+        const allowedTypes = ['application/pdf', 'application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', 'image/jpeg', 'image/jpg', 'image/png', 'image/tiff'];
+        if (!allowedTypes.includes(file.type)) {
+            alert('Unsupported file type. Please upload PDF, DOC, DOCX, JPG, PNG, or TIFF files.');
+            return;
+        }
+
+        // Validate file size (10MB limit)
+        if (file.size > 10 * 1024 * 1024) {
+            alert('File size exceeds 10MB limit.');
+            return;
+        }
+
+        this.showUploadProgress(true);
+        
+        try {
+            // Create FormData
+            const formData = new FormData();
+            formData.append('patient_id', this.currentPatientId);
+            formData.append('file', file);
+
+            // Upload and analyze document
+            const response = await fetch('/emr/preview-document', {
+                method: 'POST',
+                body: formData
+            });
+
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.detail || 'Failed to analyze document');
+            }
+
+            const result = await response.json();
+            this.showDocumentPreview(result);
+
+        } catch (error) {
+            console.error('Error uploading file:', error);
+            alert(`Error analyzing document: ${error.message}`);
+        } finally {
+            this.showUploadProgress(false);
+        }
+    }
+
+    showUploadProgress(show) {
+        const uploadProgress = document.getElementById('uploadProgress');
+        const uploadArea = document.getElementById('uploadArea');
+        
+        if (show) {
+            uploadProgress.style.display = 'block';
+            uploadArea.style.display = 'none';
+        } else {
+            uploadProgress.style.display = 'none';
+            uploadArea.style.display = 'block';
+        }
+    }
+
+    showDocumentPreview(analysisResult) {
+        const modal = document.getElementById('documentPreviewModal');
+        const content = document.getElementById('documentPreviewContent');
+        
+        // Store the analysis result for saving
+        this.currentDocumentAnalysis = analysisResult;
+
+        content.innerHTML = this.renderDocumentPreview(analysisResult);
+        modal.classList.add('show');
+    }
+
+    renderDocumentPreview(data) {
+        const { filename, confidence_score, extracted_data } = data;
+        
+        return `
+            <div class="document-preview-section">
+                <h4><i class="fas fa-file"></i> Document Information</h4>
+                <p><strong>Filename:</strong> ${filename}</p>
+                <p><strong>Confidence Score:</strong> ${Math.round(confidence_score * 100)}%</p>
+            </div>
+
+            ${extracted_data.overview ? `
+                <div class="document-preview-section">
+                    <h4><i class="fas fa-eye"></i> Overview</h4>
+                    <textarea class="editable-field" id="overviewField" rows="3">${extracted_data.overview}</textarea>
+                </div>
+            ` : ''}
+
+            <div class="document-preview-section">
+                <h4><i class="fas fa-stethoscope"></i> Diagnoses</h4>
+                <ul class="editable-list" id="diagnosisList">
+                    ${(extracted_data.diagnosis || []).map(diagnosis => `
+                        <li>
+                            <input type="text" value="${diagnosis}" class="diagnosis-input">
+                            <button type="button" onclick="emrPage.removeListItem(this)"><i class="fas fa-trash"></i></button>
+                        </li>
+                    `).join('')}
+                </ul>
+                <button type="button" class="add-item-btn" onclick="emrPage.addDiagnosis()">
+                    <i class="fas fa-plus"></i> Add Diagnosis
+                </button>
+            </div>
+
+            <div class="document-preview-section">
+                <h4><i class="fas fa-exclamation-triangle"></i> Symptoms</h4>
+                <ul class="editable-list" id="symptomsList">
+                    ${(extracted_data.symptoms || []).map(symptom => `
+                        <li>
+                            <input type="text" value="${symptom}" class="symptom-input">
+                            <button type="button" onclick="emrPage.removeListItem(this)"><i class="fas fa-trash"></i></button>
+                        </li>
+                    `).join('')}
+                </ul>
+                <button type="button" class="add-item-btn" onclick="emrPage.addSymptom()">
+                    <i class="fas fa-plus"></i> Add Symptom
+                </button>
+            </div>
+
+            <div class="document-preview-section">
+                <h4><i class="fas fa-pills"></i> Medications</h4>
+                <div id="medicationsList">
+                    ${(extracted_data.medications || []).map((med, index) => `
+                        <div class="medication-preview-item">
+                            <h5>Medication ${index + 1}</h5>
+                            <div class="medication-detail-row">
+                                <div>
+                                    <label>Name</label>
+                                    <input type="text" value="${med.name || ''}" class="med-name-input">
+                                </div>
+                                <div>
+                                    <label>Dosage</label>
+                                    <input type="text" value="${med.dosage || ''}" class="med-dosage-input">
+                                </div>
+                            </div>
+                            <div class="medication-detail-row">
+                                <div>
+                                    <label>Frequency</label>
+                                    <input type="text" value="${med.frequency || ''}" class="med-frequency-input">
+                                </div>
+                                <div>
+                                    <label>Duration</label>
+                                    <input type="text" value="${med.duration || ''}" class="med-duration-input">
+                                </div>
+                            </div>
+                            <button type="button" onclick="emrPage.removeMedication(this)" style="margin-top: 10px; background: #dc3545; color: white; border: none; padding: 5px 10px; border-radius: 4px; cursor: pointer;">
+                                <i class="fas fa-trash"></i> Remove
+                            </button>
+                        </div>
+                    `).join('')}
+                </div>
+                <button type="button" class="add-item-btn" onclick="emrPage.addMedication()">
+                    <i class="fas fa-plus"></i> Add Medication
+                </button>
+            </div>
+
+            ${extracted_data.vital_signs ? `
+                <div class="document-preview-section">
+                    <h4><i class="fas fa-heartbeat"></i> Vital Signs</h4>
+                    <div class="vital-signs-preview-grid">
+                        <div class="vital-sign-preview-item">
+                            <label>Blood Pressure</label>
+                            <input type="text" value="${extracted_data.vital_signs.blood_pressure || ''}" id="bpInput">
+                        </div>
+                        <div class="vital-sign-preview-item">
+                            <label>Heart Rate</label>
+                            <input type="text" value="${extracted_data.vital_signs.heart_rate || ''}" id="hrInput">
+                        </div>
+                        <div class="vital-sign-preview-item">
+                            <label>Temperature</label>
+                            <input type="text" value="${extracted_data.vital_signs.temperature || ''}" id="tempInput">
+                        </div>
+                        <div class="vital-sign-preview-item">
+                            <label>Respiratory Rate</label>
+                            <input type="text" value="${extracted_data.vital_signs.respiratory_rate || ''}" id="rrInput">
+                        </div>
+                        <div class="vital-sign-preview-item">
+                            <label>Oxygen Saturation</label>
+                            <input type="text" value="${extracted_data.vital_signs.oxygen_saturation || ''}" id="o2Input">
+                        </div>
+                    </div>
+                </div>
+            ` : ''}
+
+            <div class="document-preview-section">
+                <h4><i class="fas fa-flask"></i> Lab Results</h4>
+                <div id="labResultsList">
+                    ${(extracted_data.lab_results || []).map((lab, index) => `
+                        <div class="lab-result-preview-item">
+                            <h5>Lab Test ${index + 1}</h5>
+                            <div class="lab-result-detail-row">
+                                <div>
+                                    <label>Test Name</label>
+                                    <input type="text" value="${lab.test_name || ''}" class="lab-name-input">
+                                </div>
+                                <div>
+                                    <label>Value</label>
+                                    <input type="text" value="${lab.value || ''}" class="lab-value-input">
+                                </div>
+                                <div>
+                                    <label>Unit</label>
+                                    <input type="text" value="${lab.unit || ''}" class="lab-unit-input">
+                                </div>
+                            </div>
+                            <div class="lab-result-detail-row">
+                                <div>
+                                    <label>Reference Range</label>
+                                    <input type="text" value="${lab.reference_range || ''}" class="lab-range-input">
+                                </div>
+                            </div>
+                            <button type="button" onclick="emrPage.removeLabResult(this)" style="margin-top: 10px; background: #dc3545; color: white; border: none; padding: 5px 10px; border-radius: 4px; cursor: pointer;">
+                                <i class="fas fa-trash"></i> Remove
+                            </button>
+                        </div>
+                    `).join('')}
+                </div>
+                <button type="button" class="add-item-btn" onclick="emrPage.addLabResult()">
+                    <i class="fas fa-plus"></i> Add Lab Result
+                </button>
+            </div>
+
+            <div class="document-preview-section">
+                <h4><i class="fas fa-procedures"></i> Procedures</h4>
+                <ul class="editable-list" id="proceduresList">
+                    ${(extracted_data.procedures || []).map(procedure => `
+                        <li>
+                            <input type="text" value="${procedure}" class="procedure-input">
+                            <button type="button" onclick="emrPage.removeListItem(this)"><i class="fas fa-trash"></i></button>
+                        </li>
+                    `).join('')}
+                </ul>
+                <button type="button" class="add-item-btn" onclick="emrPage.addProcedure()">
+                    <i class="fas fa-plus"></i> Add Procedure
+                </button>
+            </div>
+
+            <div class="document-preview-section">
+                <h4><i class="fas fa-sticky-note"></i> Notes</h4>
+                <textarea class="editable-field" id="notesField" rows="4">${extracted_data.notes || ''}</textarea>
+            </div>
+        `;
+    }
+
+    addDiagnosis() {
+        const list = document.getElementById('diagnosisList');
+        const li = document.createElement('li');
+        li.innerHTML = `
+            <input type="text" value="" class="diagnosis-input" placeholder="Enter diagnosis">
+            <button type="button" onclick="emrPage.removeListItem(this)"><i class="fas fa-trash"></i></button>
+        `;
+        list.appendChild(li);
+    }
+
+    addSymptom() {
+        const list = document.getElementById('symptomsList');
+        const li = document.createElement('li');
+        li.innerHTML = `
+            <input type="text" value="" class="symptom-input" placeholder="Enter symptom">
+            <button type="button" onclick="emrPage.removeListItem(this)"><i class="fas fa-trash"></i></button>
+        `;
+        list.appendChild(li);
+    }
+
+    addMedication() {
+        const list = document.getElementById('medicationsList');
+        const index = list.children.length;
+        const div = document.createElement('div');
+        div.className = 'medication-preview-item';
+        div.innerHTML = `
+            <h5>Medication ${index + 1}</h5>
+            <div class="medication-detail-row">
+                <div>
+                    <label>Name</label>
+                    <input type="text" value="" class="med-name-input" placeholder="Medication name">
+                </div>
+                <div>
+                    <label>Dosage</label>
+                    <input type="text" value="" class="med-dosage-input" placeholder="Dosage">
+                </div>
+            </div>
+            <div class="medication-detail-row">
+                <div>
+                    <label>Frequency</label>
+                    <input type="text" value="" class="med-frequency-input" placeholder="Frequency">
+                </div>
+                <div>
+                    <label>Duration</label>
+                    <input type="text" value="" class="med-duration-input" placeholder="Duration">
+                </div>
+            </div>
+            <button type="button" onclick="emrPage.removeMedication(this)" style="margin-top: 10px; background: #dc3545; color: white; border: none; padding: 5px 10px; border-radius: 4px; cursor: pointer;">
+                <i class="fas fa-trash"></i> Remove
+            </button>
+        `;
+        list.appendChild(div);
+    }
+
+    addLabResult() {
+        const list = document.getElementById('labResultsList');
+        const index = list.children.length;
+        const div = document.createElement('div');
+        div.className = 'lab-result-preview-item';
+        div.innerHTML = `
+            <h5>Lab Test ${index + 1}</h5>
+            <div class="lab-result-detail-row">
+                <div>
+                    <label>Test Name</label>
+                    <input type="text" value="" class="lab-name-input" placeholder="Test name">
+                </div>
+                <div>
+                    <label>Value</label>
+                    <input type="text" value="" class="lab-value-input" placeholder="Test value">
+                </div>
+                <div>
+                    <label>Unit</label>
+                    <input type="text" value="" class="lab-unit-input" placeholder="Unit">
+                </div>
+            </div>
+            <div class="lab-result-detail-row">
+                <div>
+                    <label>Reference Range</label>
+                    <input type="text" value="" class="lab-range-input" placeholder="Normal range">
+                </div>
+            </div>
+            <button type="button" onclick="emrPage.removeLabResult(this)" style="margin-top: 10px; background: #dc3545; color: white; border: none; padding: 5px 10px; border-radius: 4px; cursor: pointer;">
+                <i class="fas fa-trash"></i> Remove
+            </button>
+        `;
+        list.appendChild(div);
+    }
+
+    addProcedure() {
+        const list = document.getElementById('proceduresList');
+        const li = document.createElement('li');
+        li.innerHTML = `
+            <input type="text" value="" class="procedure-input" placeholder="Enter procedure">
+            <button type="button" onclick="emrPage.removeListItem(this)"><i class="fas fa-trash"></i></button>
+        `;
+        list.appendChild(li);
+    }
+
+    removeListItem(button) {
+        button.parentElement.remove();
+    }
+
+    removeMedication(button) {
+        button.parentElement.remove();
+    }
+
+    removeLabResult(button) {
+        button.parentElement.remove();
+    }
+
+    async saveDocumentAnalysis() {
+        if (!this.currentDocumentAnalysis) {
+            alert('No document analysis to save');
+            return;
+        }
+
+        try {
+            // Collect all the edited data
+            const extractedData = this.collectEditedData();
+            
+            const formData = new FormData();
+            formData.append('patient_id', this.currentPatientId);
+            formData.append('filename', this.currentDocumentAnalysis.filename);
+            formData.append('extracted_data', JSON.stringify(extractedData));
+            formData.append('confidence_score', this.currentDocumentAnalysis.confidence_score);
+
+            const response = await fetch('/emr/save-document-analysis', {
+                method: 'POST',
+                body: formData
+            });
+
+            if (!response.ok) {
+                const error = await response.json();
+                throw new Error(error.detail || 'Failed to save document analysis');
+            }
+
+            const result = await response.json();
+            
+            // Close modal and refresh EMR data
+            document.getElementById('documentPreviewModal').classList.remove('show');
+            this.loadEMRData();
+            this.loadPatientStats();
+            
+            alert('Document analysis saved successfully!');
+
+        } catch (error) {
+            console.error('Error saving document analysis:', error);
+            alert(`Error saving document analysis: ${error.message}`);
+        }
+    }
+
+    collectEditedData() {
+        const data = {
+            overview: document.getElementById('overviewField')?.value || '',
+            diagnosis: Array.from(document.querySelectorAll('.diagnosis-input')).map(input => input.value).filter(val => val.trim()),
+            symptoms: Array.from(document.querySelectorAll('.symptom-input')).map(input => input.value).filter(val => val.trim()),
+            medications: Array.from(document.querySelectorAll('.medication-preview-item')).map(item => ({
+                name: item.querySelector('.med-name-input')?.value || '',
+                dosage: item.querySelector('.med-dosage-input')?.value || '',
+                frequency: item.querySelector('.med-frequency-input')?.value || '',
+                duration: item.querySelector('.med-duration-input')?.value || ''
+            })).filter(med => med.name.trim()),
+            vital_signs: {
+                blood_pressure: document.getElementById('bpInput')?.value || null,
+                heart_rate: document.getElementById('hrInput')?.value || null,
+                temperature: document.getElementById('tempInput')?.value || null,
+                respiratory_rate: document.getElementById('rrInput')?.value || null,
+                oxygen_saturation: document.getElementById('o2Input')?.value || null
+            },
+            lab_results: Array.from(document.querySelectorAll('.lab-result-preview-item')).map(item => ({
+                test_name: item.querySelector('.lab-name-input')?.value || '',
+                value: item.querySelector('.lab-value-input')?.value || '',
+                unit: item.querySelector('.lab-unit-input')?.value || '',
+                reference_range: item.querySelector('.lab-range-input')?.value || ''
+            })).filter(lab => lab.test_name.trim()),
+            procedures: Array.from(document.querySelectorAll('.procedure-input')).map(input => input.value).filter(val => val.trim()),
+            notes: document.getElementById('notesField')?.value || ''
+        };
+
+        // Clean up empty vital signs
+        if (Object.values(data.vital_signs).every(val => !val)) {
+            data.vital_signs = null;
+        }
+
+        return data;
+    }
 }
 
 // Initialize the EMR page when DOM is loaded

static/patient.html

@@ -28,7 +28,7 @@
 							<option value="Intersex">Intersex</option>
 						</select>
 					</label>
-					<label>Ethnicity<input type="ethnicity" id="ethnicity"></label>
+					<label>Ethnicity<input type="text" id="ethnicity"></label>
 				</div>
 				<!-- Row 3: Contact Information -->
 				<div class="row contact-info">

tests/{test_account.py → models/test_account.py}

@@ -10,7 +10,7 @@ from src.data.connection import ActionFailed, Collections, get_collection
 from src.data.repositories import account as account_repo
 from src.models.account import Account
 from src.utils.logger import logger
-from tests.base_test import BaseMongoTest
+from ..base_test import BaseMongoTest
 
 
 class TestAccountRepository(BaseMongoTest):

tests/{test_patient.py → models/test_patient.py}

@@ -8,7 +8,7 @@ from src.data.connection import ActionFailed, Collections, get_collection
 from src.data.repositories import patient as patient_repo
 from src.models.patient import Patient
 from src.utils.logger import logger
-from tests.base_test import BaseMongoTest
+from ..base_test import BaseMongoTest
 
 
 class TestPatientRepository(BaseMongoTest):

tests/{test_session.py → models/test_session.py}

@@ -10,7 +10,7 @@ from src.data.connection import ActionFailed, Collections, get_collection
 from src.data.repositories import session as session_repo
 from src.models.session import Message, Session
 from src.utils.logger import logger
-from tests.base_test import BaseMongoTest
+from ..base_test import BaseMongoTest
 
 
 class TestSessionRepository(BaseMongoTest):

tests/services/test_guard.py

@@ -0,0 +1,313 @@
+# tests/test_guard.py
+
+import pytest
+import os
+from unittest.mock import Mock, patch, MagicMock
+from src.services.guard import SafetyGuard
+
+
+class TestSafetyGuard:
+    """Test suite for SafetyGuard functionality."""
+
+    @pytest.fixture
+    def mock_settings(self):
+        """Mock settings for testing."""
+        with patch('src.services.guard.settings') as mock_settings:
+            mock_settings.SAFETY_GUARD_TIMEOUT = 30
+            mock_settings.SAFETY_GUARD_ENABLED = True
+            mock_settings.SAFETY_GUARD_FAIL_OPEN = True
+            yield mock_settings
+
+    @pytest.fixture
+    def mock_rotator(self):
+        """Mock NVIDIA rotator for testing."""
+        mock_rotator = Mock()
+        mock_rotator.get_key.return_value = "test_api_key"
+        mock_rotator.rotate.return_value = "test_api_key_2"
+        return mock_rotator
+
+    @pytest.fixture
+    def safety_guard(self, mock_settings, mock_rotator):
+        """Create SafetyGuard instance for testing."""
+        return SafetyGuard(mock_rotator)
+
+    def test_init_with_valid_config(self, mock_settings, mock_rotator):
+        """Test SafetyGuard initialization with valid configuration."""
+        guard = SafetyGuard(mock_rotator)
+        assert guard.nvidia_rotator == mock_rotator
+        assert guard.timeout_s == 30
+        assert guard.enabled is True
+        assert guard.fail_open is True
+
+    def test_init_without_api_key(self, mock_settings):
+        """Test SafetyGuard initialization without API key."""
+        mock_rotator = Mock()
+        mock_rotator.get_key.return_value = None
+        with pytest.raises(ValueError, match="No NVIDIA API keys found"):
+            SafetyGuard(mock_rotator)
+
+    def test_chunk_text_empty(self, safety_guard):
+        """Test text chunking with empty text."""
+        result = safety_guard._chunk_text("")
+        assert result == [""]
+
+    def test_chunk_text_short(self, safety_guard):
+        """Test text chunking with short text."""
+        text = "Short text"
+        result = safety_guard._chunk_text(text)
+        assert result == [text]
+
+    def test_chunk_text_long(self, safety_guard):
+        """Test text chunking with long text."""
+        text = "a" * 5000  # Longer than default chunk size
+        result = safety_guard._chunk_text(text)
+        assert len(result) > 1
+        assert all(len(chunk) <= 2800 for chunk in result)
+
+    def test_parse_guard_reply_safe(self, safety_guard):
+        """Test parsing safe guard reply."""
+        is_safe, reason = safety_guard._parse_guard_reply("SAFE")
+        assert is_safe is True
+        assert reason == ""
+
+    def test_parse_guard_reply_unsafe(self, safety_guard):
+        """Test parsing unsafe guard reply."""
+        is_safe, reason = safety_guard._parse_guard_reply("UNSAFE: contains harmful content")
+        assert is_safe is False
+        assert reason == "contains harmful content"
+
+    def test_parse_guard_reply_empty(self, safety_guard):
+        """Test parsing empty guard reply."""
+        is_safe, reason = safety_guard._parse_guard_reply("")
+        assert is_safe is True
+        assert reason == "guard_unavailable"
+
+    def test_parse_guard_reply_unknown(self, safety_guard):
+        """Test parsing unknown guard reply."""
+        is_safe, reason = safety_guard._parse_guard_reply("UNKNOWN_RESPONSE")
+        assert is_safe is False
+        assert len(reason) <= 180
+
+    def test_is_medical_query_symptoms(self, safety_guard):
+        """Test medical query detection for symptoms."""
+        queries = [
+            "I have a headache",
+            "My chest hurts",
+            "I'm experiencing nausea",
+            "I have a fever"
+        ]
+        for query in queries:
+            assert safety_guard._is_medical_query(query) is True
+
+    def test_is_medical_query_conditions(self, safety_guard):
+        """Test medical query detection for conditions."""
+        queries = [
+            "What is diabetes?",
+            "How to treat hypertension",
+            "Symptoms of depression",
+            "Cancer treatment options"
+        ]
+        for query in queries:
+            assert safety_guard._is_medical_query(query) is True
+
+    def test_is_medical_query_treatments(self, safety_guard):
+        """Test medical query detection for treatments."""
+        queries = [
+            "What medication should I take?",
+            "Physical therapy exercises",
+            "Surgery options",
+            "Vaccination schedule"
+        ]
+        for query in queries:
+            assert safety_guard._is_medical_query(query) is True
+
+    def test_is_medical_query_non_medical(self, safety_guard):
+        """Test medical query detection for non-medical content."""
+        queries = [
+            "What's the weather like?",
+            "How to cook pasta",
+            "Best restaurants in town",
+            "Python programming tutorial"
+        ]
+        for query in queries:
+            assert safety_guard._is_medical_query(query) is False
+
+    def test_detect_harmful_content_safe_medical(self, safety_guard):
+        """Test harmful content detection for safe medical content."""
+        text = "I have a headache and need advice on pain management"
+        is_safe, reason = safety_guard._detect_harmful_content(text)
+        assert is_safe is True
+        assert reason == "medical_content"
+
+    def test_detect_harmful_content_dangerous_medical(self, safety_guard):
+        """Test harmful content detection for dangerous medical content."""
+        text = "You should overdose on your medication"
+        is_safe, reason = safety_guard._detect_harmful_content(text)
+        assert is_safe is False
+        assert "dangerous_medical_advice" in reason
+
+    def test_detect_harmful_content_suicide(self, safety_guard):
+        """Test harmful content detection for suicide-related content."""
+        text = "How to kill yourself"
+        is_safe, reason = safety_guard._detect_harmful_content(text)
+        assert is_safe is False
+        assert "suicide_self_harm" in reason
+
+    def test_detect_harmful_content_violence(self, safety_guard):
+        """Test harmful content detection for violent content."""
+        text = "How to harm others with weapons"
+        is_safe, reason = safety_guard._detect_harmful_content(text)
+        assert is_safe is False
+        assert "violence" in reason
+
+    def test_assess_risk_level_medical_low(self, safety_guard):
+        """Test risk assessment for low-risk medical content."""
+        text = "I have a mild headache"
+        risk_level, risk_score = safety_guard._assess_risk_level(text)
+        assert risk_level == "low"
+        assert 0.0 <= risk_score <= 1.0
+
+    def test_assess_risk_level_medical_high(self, safety_guard):
+        """Test risk assessment for high-risk medical content."""
+        text = "You should commit suicide and overdose on drugs"
+        risk_level, risk_score = safety_guard._assess_risk_level(text)
+        assert risk_level == "high"
+        assert risk_score > 0.6
+
+    def test_assess_risk_level_non_medical(self, safety_guard):
+        """Test risk assessment for non-medical content."""
+        text = "This is just a normal conversation"
+        risk_level, risk_score = safety_guard._assess_risk_level(text)
+        assert risk_level == "low"
+        assert 0.0 <= risk_score <= 1.0
+
+    @patch('src.services.guard.requests.post')
+    def test_call_guard_success(self, mock_post, safety_guard):
+        """Test successful guard API call."""
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "choices": [{"message": {"content": "SAFE"}}]
+        }
+        mock_post.return_value = mock_response
+
+        messages = [{"role": "user", "content": "test message"}]
+        result = safety_guard._call_guard(messages)
+        assert result == "SAFE"
+
+    @patch('src.services.guard.requests.post')
+    def test_call_guard_failure(self, mock_post, safety_guard):
+        """Test guard API call failure."""
+        mock_response = Mock()
+        mock_response.status_code = 400
+        mock_response.text = "Bad Request"
+        mock_post.return_value = mock_response
+
+        messages = [{"role": "user", "content": "test message"}]
+        result = safety_guard._call_guard(messages)
+        assert result == ""
+
+    def test_check_user_query_disabled(self, mock_settings):
+        """Test user query check when guard is disabled."""
+        mock_settings.SAFETY_GUARD_ENABLED = False
+        guard = SafetyGuard()
+        
+        is_safe, reason = guard.check_user_query("any query")
+        assert is_safe is True
+        assert reason == "guard_disabled"
+
+    def test_check_user_query_medical(self, safety_guard):
+        """Test user query check for medical content."""
+        with patch.object(safety_guard, '_call_guard') as mock_call:
+            is_safe, reason = safety_guard.check_user_query("I have a headache")
+            assert is_safe is True
+            assert reason == "medical_query"
+            mock_call.assert_not_called()
+
+    def test_check_user_query_non_medical_safe(self, safety_guard):
+        """Test user query check for safe non-medical content."""
+        with patch.object(safety_guard, '_call_guard') as mock_call, \
+             patch.object(safety_guard, '_parse_guard_reply') as mock_parse:
+            mock_call.return_value = "SAFE"
+            mock_parse.return_value = (True, "")
+            
+            is_safe, reason = safety_guard.check_user_query("What's the weather?")
+            assert is_safe is True
+            assert reason == ""
+
+    def test_check_user_query_non_medical_unsafe(self, safety_guard):
+        """Test user query check for unsafe non-medical content."""
+        with patch.object(safety_guard, '_call_guard') as mock_call, \
+             patch.object(safety_guard, '_parse_guard_reply') as mock_parse:
+            mock_call.return_value = "UNSAFE: harmful content"
+            mock_parse.return_value = (False, "harmful content")
+            
+            is_safe, reason = safety_guard.check_user_query("How to harm others")
+            assert is_safe is False
+            assert reason == "harmful content"
+
+    def test_check_model_answer_disabled(self, mock_settings):
+        """Test model answer check when guard is disabled."""
+        mock_settings.SAFETY_GUARD_ENABLED = False
+        guard = SafetyGuard()
+        
+        is_safe, reason = guard.check_model_answer("query", "answer")
+        assert is_safe is True
+        assert reason == "guard_disabled"
+
+    def test_check_model_answer_medical_safe(self, safety_guard):
+        """Test model answer check for safe medical content."""
+        is_safe, reason = safety_guard.check_model_answer(
+            "I have a headache", 
+            "You should rest and drink water"
+        )
+        assert is_safe is True
+        assert reason == "medical_content"
+
+    def test_check_model_answer_medical_unsafe(self, safety_guard):
+        """Test model answer check for unsafe medical content."""
+        is_safe, reason = safety_guard.check_model_answer(
+            "I have a headache", 
+            "You should overdose on medication"
+        )
+        assert is_safe is False
+        assert "dangerous medical advice" in reason
+
+    def test_check_model_answer_high_risk(self, safety_guard):
+        """Test model answer check for high-risk content."""
+        with patch.object(safety_guard, '_call_guard') as mock_call, \
+             patch.object(safety_guard, '_parse_guard_reply') as mock_parse:
+            mock_call.return_value = "SAFE"
+            mock_parse.return_value = (True, "")
+            
+            is_safe, reason = safety_guard.check_model_answer(
+                "How to harm others", 
+                "You should use weapons to attack people"
+            )
+            assert is_safe is True
+            assert reason == "high_risk_validated"
+
+    def test_enhance_messages_with_context_medical(self, safety_guard):
+        """Test message enhancement for medical content."""
+        messages = [{"role": "user", "content": "I have a headache"}]
+        enhanced = safety_guard._enhance_messages_with_context(messages)
+        
+        assert len(enhanced) == 1
+        assert "MEDICAL CONTEXT" in enhanced[0]["content"]
+        assert "I have a headache" in enhanced[0]["content"]
+
+    def test_enhance_messages_with_context_non_medical(self, safety_guard):
+        """Test message enhancement for non-medical content."""
+        messages = [{"role": "user", "content": "What's the weather?"}]
+        enhanced = safety_guard._enhance_messages_with_context(messages)
+        
+        assert enhanced == messages  # Should remain unchanged
+
+    def test_global_safety_guard_instance(self):
+        """Test that global safety guard instance is None by default."""
+        from src.services.guard import safety_guard
+        assert safety_guard is None
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

tests/{test_medical_memory.py → services/test_medical_memory.py}

@@ -8,7 +8,7 @@ from src.data.connection import ActionFailed, Collections
 from src.data.repositories import medical_memory as medical_memory_repo
 from src.models.medical import MedicalMemory, SemanticSearchResult
 from src.utils.logger import logger
-from tests.base_test import BaseMongoTest
+from ..base_test import BaseMongoTest
 
 
 class TestMedicalMemoryRepository(BaseMongoTest):

tests/{test_medical_record.py → services/test_medical_record.py}

@@ -9,7 +9,7 @@ from src.data.connection import ActionFailed, Collections
 from src.data.repositories import medical_record as medical_record_repo
 from src.models.medical import MedicalRecord
 from src.utils.logger import logger
-from tests.base_test import BaseMongoTest
+from ..base_test import BaseMongoTest
 
 
 class TestMedicalRecordRepository(BaseMongoTest):

tests/{test_utils.py → utils/test_utils.py}

@@ -7,7 +7,7 @@ from pymongo.errors import ConnectionFailure
 from src.data import utils as db_utils
 from src.data.connection import ActionFailed, Collections, get_collection
 from src.utils.logger import logger
-from tests.base_test import BaseMongoTest
+from ..base_test import BaseMongoTest
 
 
 class TestDatabaseUtils(BaseMongoTest):