Upd EMR parser and updater services (OCR+VLM)

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
 
@@ -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/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/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

@@ -19,13 +19,14 @@ class SafetyGuard:
       - 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 = "meta/llama-guard-4-12b"
+        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

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);

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">
@@ -239,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/js/emr.js

@@ -58,6 +58,9 @@ class EMRPage {
 
         // Modal handlers
         this.setupModalHandlers();
+        
+        // File upload handlers
+        this.setupFileUploadHandlers();
     }
 
     setupModalHandlers() {
@@ -102,6 +105,81 @@ 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() {