Merge remote-tracking branch 'space/emr' into hf_main

.dockerignore

@@ -4,3 +4,4 @@
 .venv
 __pycache__
 *.pyc
+key

.gitignore

@@ -9,4 +9,5 @@
 **/.env
 **.DS_STORE
 
-review_vi.txt
+review_vi.txt
+key

schemas/emr_validator.json

@@ -0,0 +1,118 @@
+{
+	"$jsonSchema": {
+		"bsonType": "object",
+		"title": "EMR validator",
+		"required": [
+			"patient_id",
+			"doctor_id",
+			"message_id",
+			"session_id",
+			"extracted_data",
+			"created_at",
+			"updated_at"
+		],
+		"properties": {
+			"patient_id": {
+				"bsonType": "string",
+				"description": "ID of the patient this EMR entry belongs to"
+			},
+			"doctor_id": {
+				"bsonType": "string",
+				"description": "ID of the doctor who triggered the EMR extraction"
+			},
+			"message_id": {
+				"bsonType": "string",
+				"description": "ID of the message that was analyzed for EMR extraction"
+			},
+			"session_id": {
+				"bsonType": "string",
+				"description": "ID of the chat session this EMR entry belongs to"
+			},
+			"original_message": {
+				"bsonType": "string",
+				"description": "The original message content that was analyzed"
+			},
+			"extracted_data": {
+				"bsonType": "object",
+				"properties": {
+					"diagnosis": {
+						"bsonType": "array",
+						"items": {"bsonType": "string"},
+						"description": "List of diagnoses identified"
+					},
+					"symptoms": {
+						"bsonType": "array",
+						"items": {"bsonType": "string"},
+						"description": "List of symptoms mentioned"
+					},
+					"medications": {
+						"bsonType": "array",
+						"items": {
+							"bsonType": "object",
+							"properties": {
+								"name": {"bsonType": "string"},
+								"dosage": {"bsonType": "string"},
+								"frequency": {"bsonType": "string"},
+								"duration": {"bsonType": "string"}
+							}
+						},
+						"description": "List of medications prescribed or mentioned"
+					},
+					"vital_signs": {
+						"bsonType": "object",
+						"properties": {
+							"blood_pressure": {"bsonType": "string"},
+							"heart_rate": {"bsonType": "string"},
+							"temperature": {"bsonType": "string"},
+							"respiratory_rate": {"bsonType": "string"},
+							"oxygen_saturation": {"bsonType": "string"}
+						},
+						"description": "Vital signs mentioned in the message"
+					},
+					"lab_results": {
+						"bsonType": "array",
+						"items": {
+							"bsonType": "object",
+							"properties": {
+								"test_name": {"bsonType": "string"},
+								"value": {"bsonType": "string"},
+								"unit": {"bsonType": "string"},
+								"reference_range": {"bsonType": "string"}
+							}
+						},
+						"description": "Laboratory results mentioned"
+					},
+					"procedures": {
+						"bsonType": "array",
+						"items": {"bsonType": "string"},
+						"description": "Medical procedures mentioned or performed"
+					},
+					"notes": {
+						"bsonType": "string",
+						"description": "Additional clinical notes and observations"
+					}
+				},
+				"description": "Structured medical data extracted from the message"
+			},
+			"embeddings": {
+				"bsonType": "array",
+				"items": {"bsonType": "number"},
+				"description": "Vector embeddings for semantic search"
+			},
+			"confidence_score": {
+				"bsonType": "number",
+				"minimum": 0,
+				"maximum": 1,
+				"description": "Confidence score of the extraction (0-1)"
+			},
+			"created_at": {
+				"bsonType": "date",
+				"description": "Timestamp when the EMR entry was created"
+			},
+			"updated_at": {
+				"bsonType": "date",
+				"description": "Timestamp when the EMR entry was last updated"
+			}
+		}
+	}
+}

src/emr/__init__.py

@@ -0,0 +1,2 @@
+# EMR Module
+# Electronic Medical Records functionality for the Medical AI Assistant

src/emr/models/__init__.py

@@ -0,0 +1 @@
+# EMR Models

src/emr/models/emr.py

@@ -0,0 +1,71 @@
+# emr/models/emr.py
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel, Field
+
+
+class Medication(BaseModel):
+    name: str
+    dosage: Optional[str] = None
+    frequency: Optional[str] = None
+    duration: Optional[str] = None
+
+
+class VitalSigns(BaseModel):
+    blood_pressure: Optional[str] = None
+    heart_rate: Optional[str] = None
+    temperature: Optional[str] = None
+    respiratory_rate: Optional[str] = None
+    oxygen_saturation: Optional[str] = None
+
+
+class LabResult(BaseModel):
+    test_name: str
+    value: str
+    unit: Optional[str] = None
+    reference_range: Optional[str] = None
+
+
+class ExtractedData(BaseModel):
+    diagnosis: List[str] = Field(default_factory=list)
+    symptoms: List[str] = Field(default_factory=list)
+    medications: List[Medication] = Field(default_factory=list)
+    vital_signs: Optional[VitalSigns] = None
+    lab_results: List[LabResult] = Field(default_factory=list)
+    procedures: List[str] = Field(default_factory=list)
+    notes: Optional[str] = None
+
+
+class EMRCreateRequest(BaseModel):
+    patient_id: str
+    doctor_id: str
+    message_id: str
+    session_id: str
+    original_message: str
+    extracted_data: ExtractedData
+    confidence_score: float = Field(ge=0, le=1)
+
+
+class EMRResponse(BaseModel):
+    emr_id: str
+    patient_id: str
+    doctor_id: str
+    message_id: str
+    session_id: str
+    original_message: str
+    extracted_data: ExtractedData
+    confidence_score: float
+    created_at: datetime
+    updated_at: datetime
+
+
+class EMRSearchRequest(BaseModel):
+    patient_id: str
+    query: Optional[str] = None
+    limit: int = Field(default=20, ge=1, le=100)
+
+
+class EMRUpdateRequest(BaseModel):
+    extracted_data: Optional[ExtractedData] = None
+    confidence_score: Optional[float] = Field(None, ge=0, le=1)

src/emr/repositories/__init__.py

@@ -0,0 +1 @@
+# EMR Repositories

src/emr/repositories/emr.py

@@ -0,0 +1,285 @@
+# emr/repositories/emr.py
+
+import json
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from bson import ObjectId
+from pymongo import ASCENDING, DESCENDING
+from pymongo.errors import ConnectionFailure, OperationFailure, PyMongoError
+
+from src.data.connection import ActionFailed, create_collection, get_collection
+from src.utils.logger import logger
+from src.emr.models.emr import EMRCreateRequest, EMRResponse, ExtractedData
+
+EMR_COLLECTION = "emr"
+
+
+def create():
+    """Create the EMR collection with validation schema."""
+    try:
+        create_collection(EMR_COLLECTION, "schemas/emr_validator.json")
+        # Create indexes for better performance
+        collection = get_collection(EMR_COLLECTION)
+        collection.create_index("patient_id")
+        collection.create_index("doctor_id")
+        collection.create_index("session_id")
+        collection.create_index("message_id")
+        collection.create_index("created_at")
+        collection.create_index([("patient_id", ASCENDING), ("created_at", DESCENDING)])
+        collection.create_index([("patient_id", ASCENDING), ("doctor_id", ASCENDING)])
+        collection.create_index([("session_id", ASCENDING), ("created_at", DESCENDING)])
+        collection.create_index("confidence_score")
+        logger().info("EMR collection created successfully with indexes")
+    except Exception as e:
+        logger().error(f"Error creating EMR collection: {e}")
+        raise
+
+
+def create_emr_entry(emr_data: EMRCreateRequest, embeddings: List[float]) -> str:
+    """Create a new EMR entry in the database."""
+    try:
+        collection = get_collection(EMR_COLLECTION)
+        
+        # Check if EMR entry already exists for this message
+        existing = collection.find_one({"message_id": emr_data.message_id})
+        if existing:
+            logger().warning(f"EMR entry already exists for message {emr_data.message_id}")
+            return str(existing["_id"])
+        
+        now = datetime.now(timezone.utc)
+        
+        doc = {
+            "patient_id": emr_data.patient_id,
+            "doctor_id": emr_data.doctor_id,
+            "message_id": emr_data.message_id,
+            "session_id": emr_data.session_id,
+            "original_message": emr_data.original_message,
+            "extracted_data": emr_data.extracted_data.model_dump(),
+            "embeddings": embeddings,
+            "confidence_score": emr_data.confidence_score,
+            "created_at": now,
+            "updated_at": now
+        }
+        
+        result = collection.insert_one(doc)
+        logger().info(f"Created EMR entry for patient {emr_data.patient_id}, message {emr_data.message_id}")
+        return str(result.inserted_id)
+        
+    except Exception as e:
+        logger().error(f"Error creating EMR entry: {e}")
+        raise
+
+
+def get_emr_by_id(emr_id: str) -> Optional[Dict[str, Any]]:
+    """Get an EMR entry by its ID."""
+    try:
+        collection = get_collection(EMR_COLLECTION)
+        result = collection.find_one({"_id": ObjectId(emr_id)})
+        if result:
+            result["_id"] = str(result["_id"])
+        return result
+    except Exception as e:
+        logger().error(f"Error getting EMR by ID {emr_id}: {e}")
+        return None
+
+
+def get_patient_emr_entries(
+    patient_id: str, 
+    limit: int = 20, 
+    offset: int = 0
+) -> List[Dict[str, Any]]:
+    """Get EMR entries for a specific patient, ordered by creation date."""
+    try:
+        collection = get_collection(EMR_COLLECTION)
+        cursor = collection.find(
+            {"patient_id": patient_id}
+        ).sort("created_at", DESCENDING).skip(offset).limit(limit)
+        
+        results = []
+        for doc in cursor:
+            doc["_id"] = str(doc["_id"])
+            results.append(doc)
+        
+        logger().info(f"Retrieved {len(results)} EMR entries for patient {patient_id}")
+        return results
+        
+    except Exception as e:
+        logger().error(f"Error getting patient EMR entries: {e}")
+        return []
+
+
+def search_emr_by_semantic_similarity(
+    patient_id: str,
+    query_embeddings: List[float],
+    limit: int = 10,
+    threshold: float = 0.7
+) -> List[Dict[str, Any]]:
+    """Search EMR entries using semantic similarity with embeddings."""
+    try:
+        collection = get_collection(EMR_COLLECTION)
+        
+        # Use MongoDB's vector search capabilities if available
+        # For now, we'll implement a simple cosine similarity search
+        pipeline = [
+            {"$match": {"patient_id": patient_id}},
+            {
+                "$addFields": {
+                    "similarity": {
+                        "$let": {
+                            "vars": {
+                                "dotProduct": {
+                                    "$reduce": {
+                                        "input": {"$range": [0, {"$size": "$embeddings"}]},
+                                        "initialValue": 0,
+                                        "in": {
+                                            "$add": [
+                                                "$$value",
+                                                {
+                                                    "$multiply": [
+                                                        {"$arrayElemAt": ["$embeddings", "$$this"]},
+                                                        {"$arrayElemAt": [query_embeddings, "$$this"]}
+                                                    ]
+                                                }
+                                            ]
+                                        }
+                                    }
+                                },
+                                "magnitudeA": {
+                                    "$sqrt": {
+                                        "$reduce": {
+                                            "input": "$embeddings",
+                                            "initialValue": 0,
+                                            "in": {"$add": ["$$value", {"$multiply": ["$$this", "$$this"]}]}
+                                        }
+                                    }
+                                },
+                                "magnitudeB": {
+                                    "$sqrt": {
+                                        "$reduce": {
+                                            "input": query_embeddings,
+                                            "initialValue": 0,
+                                            "in": {"$add": ["$$value", {"$multiply": ["$$this", "$$this"]}]}
+                                        }
+                                    }
+                                }
+                            },
+                            "in": {
+                                "$divide": [
+                                    "$$dotProduct",
+                                    {"$multiply": ["$$magnitudeA", "$$magnitudeB"]}
+                                ]
+                            }
+                        }
+                    }
+                }
+            },
+            {"$match": {"similarity": {"$gte": threshold}}},
+            {"$sort": {"similarity": DESCENDING}},
+            {"$limit": limit}
+        ]
+        
+        results = list(collection.aggregate(pipeline))
+        for doc in results:
+            doc["_id"] = str(doc["_id"])
+        
+        logger().info(f"Found {len(results)} similar EMR entries for patient {patient_id}")
+        return results
+        
+    except Exception as e:
+        logger().error(f"Error searching EMR by similarity: {e}")
+        return []
+
+
+def update_emr_entry(emr_id: str, updates: Dict[str, Any]) -> bool:
+    """Update an EMR entry."""
+    try:
+        collection = get_collection(EMR_COLLECTION)
+        updates["updated_at"] = datetime.now(timezone.utc)
+        
+        result = collection.update_one(
+            {"_id": ObjectId(emr_id)},
+            {"$set": updates}
+        )
+        
+        success = result.modified_count > 0
+        if success:
+            logger().info(f"Updated EMR entry {emr_id}")
+        else:
+            logger().warning(f"No EMR entry found with ID {emr_id}")
+        
+        return success
+        
+    except Exception as e:
+        logger().error(f"Error updating EMR entry {emr_id}: {e}")
+        return False
+
+
+def delete_emr_entry(emr_id: str) -> bool:
+    """Delete an EMR entry."""
+    try:
+        collection = get_collection(EMR_COLLECTION)
+        result = collection.delete_one({"_id": ObjectId(emr_id)})
+        
+        success = result.deleted_count > 0
+        if success:
+            logger().info(f"Deleted EMR entry {emr_id}")
+        else:
+            logger().warning(f"No EMR entry found with ID {emr_id}")
+        
+        return success
+        
+    except Exception as e:
+        logger().error(f"Error deleting EMR entry {emr_id}: {e}")
+        return False
+
+
+def check_emr_exists(message_id: str) -> bool:
+    """Check if an EMR entry already exists for a message."""
+    try:
+        collection = get_collection(EMR_COLLECTION)
+        existing = collection.find_one({"message_id": message_id})
+        return existing is not None
+    except Exception as e:
+        logger().error(f"Error checking EMR existence: {e}")
+        return False
+
+
+def get_emr_statistics(patient_id: str) -> Dict[str, Any]:
+    """Get EMR statistics for a patient."""
+    try:
+        collection = get_collection(EMR_COLLECTION)
+        
+        pipeline = [
+            {"$match": {"patient_id": patient_id}},
+            {
+                "$group": {
+                    "_id": None,
+                    "total_entries": {"$sum": 1},
+                    "avg_confidence": {"$avg": "$confidence_score"},
+                    "latest_entry": {"$max": "$created_at"},
+                    "diagnosis_count": {
+                        "$sum": {"$size": "$extracted_data.diagnosis"}
+                    },
+                    "medication_count": {
+                        "$sum": {"$size": "$extracted_data.medications"}
+                    }
+                }
+            }
+        ]
+        
+        result = list(collection.aggregate(pipeline))
+        if result:
+            return result[0]
+        else:
+            return {
+                "total_entries": 0,
+                "avg_confidence": 0,
+                "latest_entry": None,
+                "diagnosis_count": 0,
+                "medication_count": 0
+            }
+            
+    except Exception as e:
+        logger().error(f"Error getting EMR statistics: {e}")
+        return {}

src/emr/routes/__init__.py

@@ -0,0 +1 @@
+# EMR Routes

src/emr/routes/emr.py

@@ -0,0 +1,326 @@
+# emr/routes/emr.py
+
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from fastapi import APIRouter, HTTPException, Depends
+
+from src.core.state import MedicalState, get_state
+from src.emr.models.emr import EMRResponse, EMRSearchRequest, EMRUpdateRequest
+from src.emr.services.service import EMRService
+from src.utils.logger import logger
+
+router = APIRouter(prefix="/emr", tags=["EMR"])
+
+
+@router.get("/check/{message_id}", response_model=dict)
+async def check_emr_exists(message_id: str):
+    """Check if EMR extraction has already been done for a message."""
+    try:
+        from src.emr.repositories.emr import check_emr_exists
+        exists = check_emr_exists(message_id)
+        return {
+            "message_id": message_id,
+            "emr_exists": exists
+        }
+    except Exception as e:
+        logger().error(f"Error checking EMR existence: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/health", response_model=dict)
+async def emr_health_check():
+    """Health check endpoint for EMR service."""
+    try:
+        from src.data.connection import get_collection
+        collection = get_collection("emr")
+        # Try to count documents to verify collection exists and is accessible
+        count = collection.count_documents({})
+        return {
+            "status": "healthy",
+            "collection": "emr",
+            "document_count": count,
+            "timestamp": datetime.now(timezone.utc).isoformat()
+        }
+    except Exception as e:
+        logger().error(f"EMR health check failed: {e}")
+        return {
+            "status": "unhealthy",
+            "error": str(e),
+            "timestamp": datetime.now(timezone.utc).isoformat()
+        }
+
+
+def get_emr_service(state: MedicalState = Depends(get_state)) -> EMRService:
+    """Get EMR service instance."""
+    return EMRService(state.gemini_rotator, state.embedding_client)
+
+
+@router.post("/extract", response_model=dict)
+async def extract_emr_from_message(
+    patient_id: str,
+    doctor_id: str,
+    message_id: str,
+    session_id: str,
+    message: str,
+    emr_service: EMRService = Depends(get_emr_service)
+):
+    """Extract and store EMR data from a chat message."""
+    try:
+        # Input validation
+        if not patient_id or not patient_id.strip():
+            raise HTTPException(status_code=400, detail="Patient ID is required")
+        if not doctor_id or not doctor_id.strip():
+            raise HTTPException(status_code=400, detail="Doctor ID is required")
+        if not message_id or not message_id.strip():
+            raise HTTPException(status_code=400, detail="Message ID is required")
+        if not session_id or not session_id.strip():
+            raise HTTPException(status_code=400, detail="Session ID is required")
+        if not message or not message.strip():
+            raise HTTPException(status_code=400, detail="Message content is required")
+        
+        logger().info(f"EMR extraction requested for patient {patient_id}, message {message_id}")
+        
+        # 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.get("name"),
+                    "age": patient.get("age"),
+                    "sex": patient.get("sex"),
+                    "medications": patient.get("medications", []),
+                    "past_assessment_summary": patient.get("past_assessment_summary")
+                }
+        except Exception as e:
+            logger().warning(f"Could not fetch patient context: {e}")
+        
+        # Extract and store EMR data
+        emr_id = await emr_service.extract_and_store_emr(
+            patient_id=patient_id,
+            doctor_id=doctor_id,
+            message_id=message_id,
+            session_id=session_id,
+            message=message,
+            patient_context=patient_context
+        )
+        
+        return {
+            "emr_id": emr_id,
+            "message": "EMR data extracted and stored successfully"
+        }
+        
+    except Exception as e:
+        logger().error(f"Error in EMR extraction endpoint: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/patient/{patient_id}", response_model=List[EMRResponse])
+async def get_patient_emr(
+    patient_id: str,
+    limit: int = 20,
+    offset: int = 0,
+    emr_service: EMRService = Depends(get_emr_service)
+):
+    """Get EMR entries for a specific patient."""
+    try:
+        logger().info(f"Getting EMR entries for patient {patient_id}")
+        
+        entries = await emr_service.get_patient_emr(patient_id, limit, offset)
+        return entries
+        
+    except Exception as e:
+        logger().error(f"Error getting patient EMR: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/search/{patient_id}", response_model=List[EMRResponse])
+async def search_patient_emr(
+    patient_id: str,
+    query: str,
+    limit: int = 10,
+    emr_service: EMRService = Depends(get_emr_service)
+):
+    """Search EMR entries for a patient using semantic similarity."""
+    try:
+        logger().info(f"Searching EMR for patient {patient_id} with query: {query}")
+        
+        entries = await emr_service.search_emr_semantic(patient_id, query, limit)
+        return entries
+        
+    except Exception as e:
+        logger().error(f"Error searching patient EMR: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/{emr_id}", response_model=EMRResponse)
+async def get_emr_by_id(
+    emr_id: str,
+    emr_service: EMRService = Depends(get_emr_service)
+):
+    """Get a specific EMR entry by ID."""
+    try:
+        logger().info(f"Getting EMR entry {emr_id}")
+        
+        entry = await emr_service.get_emr_by_id(emr_id)
+        if not entry:
+            raise HTTPException(status_code=404, detail="EMR entry not found")
+        
+        return entry
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger().error(f"Error getting EMR by ID: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.patch("/{emr_id}", response_model=dict)
+async def update_emr(
+    emr_id: str,
+    request: EMRUpdateRequest,
+    emr_service: EMRService = Depends(get_emr_service)
+):
+    """Update an EMR entry."""
+    try:
+        logger().info(f"Updating EMR entry {emr_id}")
+        
+        updates = {}
+        if request.extracted_data:
+            updates["extracted_data"] = request.extracted_data.model_dump()
+        if request.confidence_score is not None:
+            updates["confidence_score"] = request.confidence_score
+        
+        success = await emr_service.update_emr(emr_id, updates)
+        if not success:
+            raise HTTPException(status_code=404, detail="EMR entry not found")
+        
+        return {"message": "EMR entry updated successfully"}
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger().error(f"Error updating EMR: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/{emr_id}", response_model=dict)
+async def delete_emr(
+    emr_id: str,
+    emr_service: EMRService = Depends(get_emr_service)
+):
+    """Delete an EMR entry."""
+    try:
+        logger().info(f"Deleting EMR entry {emr_id}")
+        
+        success = await emr_service.delete_emr(emr_id)
+        if not success:
+            raise HTTPException(status_code=404, detail="EMR entry not found")
+        
+        return {"message": "EMR entry deleted successfully"}
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger().error(f"Error deleting EMR: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/statistics/{patient_id}", response_model=dict)
+async def get_emr_statistics(
+    patient_id: str,
+    emr_service: EMRService = Depends(get_emr_service)
+):
+    """Get EMR statistics for a patient."""
+    try:
+        logger().info(f"Getting EMR statistics for patient {patient_id}")
+        
+        stats = await emr_service.get_emr_statistics(patient_id)
+        return stats
+        
+    except Exception as e:
+        logger().error(f"Error getting EMR statistics: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/bulk-extract", response_model=dict)
+async def bulk_extract_emr(
+    extractions: List[dict],
+    emr_service: EMRService = Depends(get_emr_service)
+):
+    """Extract EMR data from multiple messages in bulk."""
+    try:
+        if not extractions or len(extractions) == 0:
+            raise HTTPException(status_code=400, detail="No extractions provided")
+        
+        if len(extractions) > 10:
+            raise HTTPException(status_code=400, detail="Maximum 10 extractions allowed per request")
+        
+        logger().info(f"Bulk EMR extraction requested for {len(extractions)} messages")
+        
+        results = []
+        errors = []
+        
+        for i, extraction in enumerate(extractions):
+            try:
+                # Validate required fields
+                required_fields = ['patient_id', 'doctor_id', 'message_id', 'session_id', 'message']
+                for field in required_fields:
+                    if field not in extraction or not extraction[field]:
+                        raise ValueError(f"Missing or empty {field}")
+                
+                # Get patient context
+                patient_context = None
+                try:
+                    from src.data.repositories.patient import get_patient_by_id
+                    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")
+                        }
+                except Exception as e:
+                    logger().warning(f"Could not fetch patient context for extraction {i}: {e}")
+                
+                # Extract and store EMR data
+                emr_id = await emr_service.extract_and_store_emr(
+                    patient_id=extraction['patient_id'],
+                    doctor_id=extraction['doctor_id'],
+                    message_id=extraction['message_id'],
+                    session_id=extraction['session_id'],
+                    message=extraction['message'],
+                    patient_context=patient_context
+                )
+                
+                results.append({
+                    "index": i,
+                    "message_id": extraction['message_id'],
+                    "emr_id": emr_id,
+                    "status": "success"
+                })
+                
+            except Exception as e:
+                logger().error(f"Error in bulk extraction {i}: {e}")
+                errors.append({
+                    "index": i,
+                    "message_id": extraction.get('message_id', 'unknown'),
+                    "error": str(e),
+                    "status": "failed"
+                })
+        
+        return {
+            "message": f"Bulk extraction completed. {len(results)} successful, {len(errors)} failed.",
+            "results": results,
+            "errors": errors
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger().error(f"Error in bulk EMR extraction: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

src/emr/services/__init__.py

@@ -0,0 +1 @@
+# EMR Services

src/emr/services/extractor.py

@@ -0,0 +1,260 @@
+# emr/services/extractor.py
+
+import json
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+from src.emr.models.emr import ExtractedData, Medication, VitalSigns, LabResult
+from src.services.gemini import gemini_chat
+from src.utils.rotator import APIKeyRotator
+from src.utils.logger import logger
+
+
+class EMRExtractor:
+    """Service for extracting structured medical data from chat messages using Gemini AI."""
+    
+    def __init__(self, gemini_rotator: APIKeyRotator):
+        self.gemini_rotator = gemini_rotator
+    
+    async def extract_medical_data(self, message: str, patient_context: Optional[Dict[str, Any]] = None) -> Tuple[ExtractedData, float]:
+        """
+        Extract structured medical data from a chat message using Gemini AI.
+        
+        Args:
+            message: The chat message to analyze
+            patient_context: Optional patient context information
+            
+        Returns:
+            Tuple of (ExtractedData, confidence_score)
+        """
+        try:
+            # Prepare the prompt for Gemini
+            prompt = self._build_extraction_prompt(message, 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 extracted medical data with confidence {confidence:.2f}")
+            return extracted_data, confidence
+            
+        except Exception as e:
+            logger().error(f"Error extracting medical data: {e}")
+            # Return empty data with low confidence
+            return ExtractedData(), 0.0
+    
+    def _build_extraction_prompt(self, message: str, patient_context: Optional[Dict[str, Any]] = None) -> str:
+        """Build the prompt for Gemini AI to extract medical data."""
+        
+        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')}
+"""
+        
+        prompt = f"""You are a medical AI assistant specialized in extracting structured medical data from clinical conversations. 
+
+{context_info}
+
+Please analyze the following medical message and extract all relevant clinical information in the specified JSON format:
+
+Message: "{message}"
+
+Extract the following information and return ONLY a valid JSON object with this exact structure:
+
+{{
+    "diagnosis": ["list of diagnoses mentioned"],
+    "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"],
+    "notes": "additional clinical notes and observations"
+}}
+
+Guidelines:
+1. Only extract information that is explicitly mentioned or clearly implied
+2. Use medical terminology appropriately
+3. If a field has no relevant information, use an empty array [] or null
+4. For medications, only include those that are prescribed, recommended, or mentioned as current
+5. Extract vital signs only if specific values are mentioned
+6. Include lab results only if specific test values are provided
+7. Be conservative - it's better to miss something than to hallucinate information
+8. 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:
+- Clarity of medical information in the message
+- Specificity of clinical details
+- Presence of measurable values (vitals, lab results)
+- Overall clinical relevance
+
+Format: CONFIDENCE: 0.85
+
+Return the JSON followed by the confidence score on a new line."""
+
+        return prompt
+    
+    async def _call_gemini_api(self, prompt: str) -> str:
+        """Call the Gemini API with the extraction prompt."""
+        try:
+            # Use the gemini_chat function with the rotator
+            response = await gemini_chat(prompt, self.gemini_rotator)
+            return response
+        except Exception as e:
+            logger().error(f"Error calling Gemini API: {e}")
+            raise
+    
+    def _parse_gemini_response(self, response: str) -> Tuple[ExtractedData, float]:
+        """Parse the Gemini response to extract structured data and confidence score."""
+        try:
+            # Extract confidence score
+            confidence = 0.5  # Default confidence
+            confidence_match = re.search(r'CONFIDENCE:\s*([0-9.]+)', response)
+            if confidence_match:
+                confidence = float(confidence_match.group(1))
+            
+            # Extract JSON from response
+            json_match = re.search(r'\{.*\}', response, re.DOTALL)
+            if not json_match:
+                logger().warning("No JSON found in Gemini response")
+                return ExtractedData(), confidence
+            
+            json_str = json_match.group(0)
+            data = json.loads(json_str)
+            
+            # Parse medications
+            medications = []
+            for med_data in data.get('medications', []):
+                if isinstance(med_data, dict):
+                    medications.append(Medication(
+                        name=med_data.get('name', ''),
+                        dosage=med_data.get('dosage'),
+                        frequency=med_data.get('frequency'),
+                        duration=med_data.get('duration')
+                    ))
+            
+            # Parse vital signs
+            vital_signs_data = data.get('vital_signs', {})
+            vital_signs = None
+            if vital_signs_data and any(vital_signs_data.values()):
+                vital_signs = VitalSigns(
+                    blood_pressure=vital_signs_data.get('blood_pressure'),
+                    heart_rate=vital_signs_data.get('heart_rate'),
+                    temperature=vital_signs_data.get('temperature'),
+                    respiratory_rate=vital_signs_data.get('respiratory_rate'),
+                    oxygen_saturation=vital_signs_data.get('oxygen_saturation')
+                )
+            
+            # Parse lab results
+            lab_results = []
+            for lab_data in data.get('lab_results', []):
+                if isinstance(lab_data, dict):
+                    lab_results.append(LabResult(
+                        test_name=lab_data.get('test_name', ''),
+                        value=lab_data.get('value', ''),
+                        unit=lab_data.get('unit'),
+                        reference_range=lab_data.get('reference_range')
+                    ))
+            
+            # Create ExtractedData object
+            extracted_data = ExtractedData(
+                diagnosis=data.get('diagnosis', []),
+                symptoms=data.get('symptoms', []),
+                medications=medications,
+                vital_signs=vital_signs,
+                lab_results=lab_results,
+                procedures=data.get('procedures', []),
+                notes=data.get('notes')
+            )
+            
+            return extracted_data, confidence
+            
+        except json.JSONDecodeError as e:
+            logger().error(f"Error parsing JSON from Gemini response: {e}")
+            return ExtractedData(), 0.0
+        except Exception as e:
+            logger().error(f"Error parsing Gemini response: {e}")
+            return ExtractedData(), 0.0
+    
+    def extract_medications_from_text(self, text: str) -> List[str]:
+        """Extract medication names from text using pattern matching."""
+        # Common medication patterns
+        medication_patterns = [
+            r'\b(?:acetaminophen|tylenol|ibuprofen|advil|motrin|aspirin|naproxen|aleve)\b',
+            r'\b(?:metformin|insulin|glipizide|metoprolol|lisinopril|amlodipine|atorvastatin|simvastatin)\b',
+            r'\b(?:omeprazole|pantoprazole|ranitidine|famotidine|sertraline|fluoxetine|paroxetine)\b',
+            r'\b(?:prednisone|hydrocortisone|dexamethasone|methylprednisolone)\b',
+            r'\b(?:warfarin|heparin|clopidogrel|aspirin)\b',
+            r'\b(?:furosemide|hydrochlorothiazide|spironolactone|triamterene)\b'
+        ]
+        
+        medications = set()
+        for pattern in medication_patterns:
+            matches = re.findall(pattern, text, re.IGNORECASE)
+            medications.update(matches)
+        
+        return list(medications)
+    
+    def extract_vital_signs_from_text(self, text: str) -> Dict[str, str]:
+        """Extract vital signs from text using pattern matching."""
+        vital_signs = {}
+        
+        # Blood pressure patterns
+        bp_pattern = r'(?:blood pressure|bp|pressure)\s*:?\s*(\d{2,3}/\d{2,3})'
+        bp_match = re.search(bp_pattern, text, re.IGNORECASE)
+        if bp_match:
+            vital_signs['blood_pressure'] = bp_match.group(1)
+        
+        # Heart rate patterns
+        hr_pattern = r'(?:heart rate|hr|pulse)\s*:?\s*(\d{2,3})\s*(?:bpm|beats per minute)?'
+        hr_match = re.search(hr_pattern, text, re.IGNORECASE)
+        if hr_match:
+            vital_signs['heart_rate'] = hr_match.group(1)
+        
+        # Temperature patterns
+        temp_pattern = r'(?:temperature|temp|fever)\s*:?\s*(\d{2,3}(?:\.\d)?)\s*(?:°?[fc])?'
+        temp_match = re.search(temp_pattern, text, re.IGNORECASE)
+        if temp_match:
+            vital_signs['temperature'] = temp_match.group(1)
+        
+        # Respiratory rate patterns
+        rr_pattern = r'(?:respiratory rate|rr|breathing rate)\s*:?\s*(\d{1,2})\s*(?:breaths per minute|bpm)?'
+        rr_match = re.search(rr_pattern, text, re.IGNORECASE)
+        if rr_match:
+            vital_signs['respiratory_rate'] = rr_match.group(1)
+        
+        # Oxygen saturation patterns
+        o2_pattern = r'(?:oxygen saturation|o2 sat|spo2)\s*:?\s*(\d{2,3})\s*%?'
+        o2_match = re.search(o2_pattern, text, re.IGNORECASE)
+        if o2_match:
+            vital_signs['oxygen_saturation'] = o2_match.group(1)
+        
+        return vital_signs

src/emr/services/service.py

@@ -0,0 +1,263 @@
+# emr/services/service.py
+
+from typing import Any, Dict, List, Optional
+
+from src.emr.models.emr import EMRCreateRequest, EMRResponse, ExtractedData
+from src.emr.repositories.emr import (
+    create_emr_entry,
+    get_patient_emr_entries,
+    get_emr_by_id,
+    search_emr_by_semantic_similarity,
+    update_emr_entry,
+    delete_emr_entry,
+    get_emr_statistics
+)
+from src.emr.services.extractor import EMRExtractor
+from src.utils.rotator import APIKeyRotator
+from src.utils.embeddings import EmbeddingClient
+from src.utils.logger import logger
+
+
+class EMRService:
+    """Main service for EMR operations including extraction, storage, and retrieval."""
+    
+    def __init__(self, gemini_rotator: APIKeyRotator, embedding_client: EmbeddingClient):
+        self.gemini_rotator = gemini_rotator
+        self.embedding_client = embedding_client
+        self.extractor = EMRExtractor(gemini_rotator)
+    
+    async def extract_and_store_emr(
+        self,
+        patient_id: str,
+        doctor_id: str,
+        message_id: str,
+        session_id: str,
+        message: str,
+        patient_context: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Extract medical data from a message and store it as an EMR entry.
+        
+        Args:
+            patient_id: ID of the patient
+            doctor_id: ID of the doctor
+            message_id: ID of the message being analyzed
+            session_id: ID of the chat session
+            message: The message content to analyze
+            patient_context: Optional patient context information
+            
+        Returns:
+            ID of the created EMR entry
+        """
+        try:
+            logger().info(f"Starting EMR extraction for patient {patient_id}, message {message_id}")
+            
+            # Extract medical data using Gemini AI
+            extracted_data, confidence = await self.extractor.extract_medical_data(
+                message, patient_context
+            )
+            
+            # Generate embeddings for the extracted data
+            embeddings = await self._generate_embeddings(extracted_data, message)
+            
+            # Create EMR entry
+            emr_request = EMRCreateRequest(
+                patient_id=patient_id,
+                doctor_id=doctor_id,
+                message_id=message_id,
+                session_id=session_id,
+                original_message=message,
+                extracted_data=extracted_data,
+                confidence_score=confidence
+            )
+            
+            # Store in database
+            emr_id = create_emr_entry(emr_request, embeddings)
+            
+            logger().info(f"Successfully created EMR entry {emr_id} with confidence {confidence:.2f}")
+            return emr_id
+            
+        except Exception as e:
+            logger().error(f"Error in extract_and_store_emr: {e}")
+            raise
+    
+    async def _generate_embeddings(self, extracted_data: ExtractedData, original_message: str) -> List[float]:
+        """Generate embeddings for the extracted medical data."""
+        try:
+            # Combine all extracted data into a single text for embedding
+            text_parts = []
+            
+            if extracted_data.diagnosis:
+                text_parts.append(f"Diagnoses: {', '.join(extracted_data.diagnosis)}")
+            
+            if extracted_data.symptoms:
+                text_parts.append(f"Symptoms: {', '.join(extracted_data.symptoms)}")
+            
+            if extracted_data.medications:
+                med_text = []
+                for med in extracted_data.medications:
+                    med_str = med.name
+                    if med.dosage:
+                        med_str += f" {med.dosage}"
+                    if med.frequency:
+                        med_str += f" {med.frequency}"
+                    med_text.append(med_str)
+                text_parts.append(f"Medications: {', '.join(med_text)}")
+            
+            if extracted_data.vital_signs:
+                vitals = []
+                if extracted_data.vital_signs.blood_pressure:
+                    vitals.append(f"BP: {extracted_data.vital_signs.blood_pressure}")
+                if extracted_data.vital_signs.heart_rate:
+                    vitals.append(f"HR: {extracted_data.vital_signs.heart_rate}")
+                if extracted_data.vital_signs.temperature:
+                    vitals.append(f"Temp: {extracted_data.vital_signs.temperature}")
+                if vitals:
+                    text_parts.append(f"Vital Signs: {', '.join(vitals)}")
+            
+            if extracted_data.lab_results:
+                lab_text = []
+                for lab in extracted_data.lab_results:
+                    lab_str = f"{lab.test_name}: {lab.value}"
+                    if lab.unit:
+                        lab_str += f" {lab.unit}"
+                    lab_text.append(lab_str)
+                text_parts.append(f"Lab Results: {', '.join(lab_text)}")
+            
+            if extracted_data.procedures:
+                text_parts.append(f"Procedures: {', '.join(extracted_data.procedures)}")
+            
+            if extracted_data.notes:
+                text_parts.append(f"Notes: {extracted_data.notes}")
+            
+            # Add original message for context
+            text_parts.append(f"Original: {original_message}")
+            
+            # Generate embeddings
+            combined_text = " | ".join(text_parts)
+            embeddings = await self.embedding_client.generate_embeddings(combined_text)
+            
+            return embeddings
+            
+        except Exception as e:
+            logger().error(f"Error generating embeddings: {e}")
+            # Return empty embeddings if generation fails
+            return []
+    
+    async def get_patient_emr(
+        self,
+        patient_id: str,
+        limit: int = 20,
+        offset: int = 0
+    ) -> List[EMRResponse]:
+        """Get EMR entries for a specific patient."""
+        try:
+            entries = get_patient_emr_entries(patient_id, limit, offset)
+            
+            emr_responses = []
+            for entry in entries:
+                emr_response = EMRResponse(
+                    emr_id=str(entry["_id"]),
+                    patient_id=entry["patient_id"],
+                    doctor_id=entry["doctor_id"],
+                    message_id=entry["message_id"],
+                    session_id=entry["session_id"],
+                    original_message=entry["original_message"],
+                    extracted_data=ExtractedData(**entry["extracted_data"]),
+                    confidence_score=entry["confidence_score"],
+                    created_at=entry["created_at"],
+                    updated_at=entry["updated_at"]
+                )
+                emr_responses.append(emr_response)
+            
+            return emr_responses
+            
+        except Exception as e:
+            logger().error(f"Error getting patient EMR: {e}")
+            return []
+    
+    async def search_emr_semantic(
+        self,
+        patient_id: str,
+        query: str,
+        limit: int = 10
+    ) -> List[EMRResponse]:
+        """Search EMR entries using semantic similarity."""
+        try:
+            # Generate embeddings for the search query
+            query_embeddings = await self.embedding_client.generate_embeddings(query)
+            
+            # Search using semantic similarity
+            entries = search_emr_by_semantic_similarity(
+                patient_id, query_embeddings, limit
+            )
+            
+            emr_responses = []
+            for entry in entries:
+                emr_response = EMRResponse(
+                    emr_id=str(entry["_id"]),
+                    patient_id=entry["patient_id"],
+                    doctor_id=entry["doctor_id"],
+                    message_id=entry["message_id"],
+                    session_id=entry["session_id"],
+                    original_message=entry["original_message"],
+                    extracted_data=ExtractedData(**entry["extracted_data"]),
+                    confidence_score=entry["confidence_score"],
+                    created_at=entry["created_at"],
+                    updated_at=entry["updated_at"]
+                )
+                emr_responses.append(emr_response)
+            
+            return emr_responses
+            
+        except Exception as e:
+            logger().error(f"Error searching EMR semantically: {e}")
+            return []
+    
+    async def get_emr_by_id(self, emr_id: str) -> Optional[EMRResponse]:
+        """Get a specific EMR entry by ID."""
+        try:
+            entry = get_emr_by_id(emr_id)
+            if not entry:
+                return None
+            
+            return EMRResponse(
+                emr_id=str(entry["_id"]),
+                patient_id=entry["patient_id"],
+                doctor_id=entry["doctor_id"],
+                message_id=entry["message_id"],
+                session_id=entry["session_id"],
+                original_message=entry["original_message"],
+                extracted_data=ExtractedData(**entry["extracted_data"]),
+                confidence_score=entry["confidence_score"],
+                created_at=entry["created_at"],
+                updated_at=entry["updated_at"]
+            )
+            
+        except Exception as e:
+            logger().error(f"Error getting EMR by ID: {e}")
+            return None
+    
+    async def update_emr(self, emr_id: str, updates: Dict[str, Any]) -> bool:
+        """Update an EMR entry."""
+        try:
+            return update_emr_entry(emr_id, updates)
+        except Exception as e:
+            logger().error(f"Error updating EMR: {e}")
+            return False
+    
+    async def delete_emr(self, emr_id: str) -> bool:
+        """Delete an EMR entry."""
+        try:
+            return delete_emr_entry(emr_id)
+        except Exception as e:
+            logger().error(f"Error deleting EMR: {e}")
+            return False
+    
+    async def get_emr_statistics(self, patient_id: str) -> Dict[str, Any]:
+        """Get EMR statistics for a patient."""
+        try:
+            return get_emr_statistics(patient_id)
+        except Exception as e:
+            logger().error(f"Error getting EMR statistics: {e}")
+            return {}

src/main.py

@@ -31,11 +31,13 @@ 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
 from src.api.routes import system as system_route
+from src.emr.routes import emr as emr_route
 from src.core.state import MedicalState, get_state
 from src.data.repositories import account as account_repo
 from src.data.repositories import medical as medical_repo
 from src.data.repositories import patient as patient_repo
 from src.data.repositories import session as session_repo
+from src.emr.repositories import emr as emr_repo
 
 
 def startup_event(state: MedicalState):
@@ -82,6 +84,7 @@ def startup_event(state: MedicalState):
 	patient_repo.init()
 	session_repo.init()
 	#medical_repo.init()
+	emr_repo.create()
 
 def shutdown_event():
 	"""Cleanup on shutdown"""
@@ -127,6 +130,7 @@ app.include_router(account_route.router)
 app.include_router(system_route.router)
 app.include_router(static_route.router)
 app.include_router(audio_route.router)
+app.include_router(emr_route.router)
 
 @app.get("/api/info")
 async def get_api_info():

static/css/emr.css

@@ -1,14 +1,15 @@
-/* EMR Page Styles */
+/* EMR Page Specific Styles */
+
 .emr-container {
     min-height: 100vh;
-    background-color: var(--bg-primary);
-    color: var(--text-primary);
+    background-color: var(--bg-secondary);
 }
 
+/* Header */
 .emr-header {
-    background-color: var(--bg-secondary);
+    background-color: var(--bg-primary);
     border-bottom: 1px solid var(--border-color);
-    padding: 1rem 0;
+    padding: var(--spacing-lg);
     position: sticky;
     top: 0;
     z-index: 100;
@@ -17,339 +18,517 @@
 .emr-header-content {
     max-width: 1200px;
     margin: 0 auto;
-    padding: 0 1rem;
     display: flex;
-    align-items: center;
     justify-content: space-between;
-    flex-wrap: wrap;
-    gap: 1rem;
+    align-items: center;
 }
 
-.back-link {
-    display: inline-flex;
+.emr-title {
+    display: flex;
     align-items: center;
-    gap: 0.5rem;
-    color: var(--primary-color);
-    text-decoration: none;
-    padding: 0.5rem 1rem;
-    border-radius: 6px;
-    transition: background-color var(--transition-fast);
+    gap: var(--spacing-md);
 }
 
-.back-link:hover {
-    background-color: var(--bg-tertiary);
+.emr-title i {
+    font-size: 1.5rem;
+    color: var(--primary-color);
 }
 
-.emr-header h1 {
+.emr-title h1 {
     margin: 0;
+    color: var(--text-primary);
     font-size: 1.5rem;
     font-weight: 600;
-    color: var(--text-primary);
 }
 
-.patient-info-header {
+.emr-actions {
     display: flex;
-    flex-direction: column;
-    align-items: flex-end;
-    text-align: right;
-}
-
-.patient-name {
-    font-size: 1.1rem;
-    font-weight: 600;
-    color: var(--text-primary);
-}
-
-.patient-id {
-    font-size: 0.9rem;
-    color: var(--text-secondary);
-    font-family: monospace;
+    gap: var(--spacing-md);
+    align-items: center;
 }
 
-.emr-main {
+/* Patient Info Bar */
+.patient-info-bar {
+    background-color: var(--bg-primary);
+    border-bottom: 1px solid var(--border-color);
+    padding: var(--spacing-lg);
     max-width: 1200px;
     margin: 0 auto;
-    padding: 2rem 1rem;
 }
 
-.emr-section {
-    background-color: var(--bg-secondary);
-    border: 1px solid var(--border-color);
-    border-radius: 8px;
-    padding: 1.5rem;
-    margin-bottom: 2rem;
+.patient-info {
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-md);
+    margin-bottom: var(--spacing-md);
 }
 
-.emr-section h2 {
-    margin: 0 0 1.5rem 0;
-    font-size: 1.25rem;
-    font-weight: 600;
-    color: var(--text-primary);
+.patient-avatar {
+    width: 48px;
+    height: 48px;
+    border-radius: 50%;
+    background-color: var(--primary-color);
+    color: white;
     display: flex;
     align-items: center;
-    gap: 0.5rem;
+    justify-content: center;
+    font-size: 1.25rem;
 }
 
-.emr-section h2 i {
-    color: var(--primary-color);
+.patient-details h3 {
+    margin: 0;
+    color: var(--text-primary);
+    font-size: 1.125rem;
 }
 
-.emr-grid {
-    display: flex;
-    flex-direction: column;
-    gap: 16px;
+.patient-details p {
+    margin: 0;
+    color: var(--text-secondary);
+    font-size: 0.875rem;
 }
 
-.emr-grid .row {
+.patient-stats {
     display: grid;
-    gap: 16px;
+    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+    gap: var(--spacing-md);
 }
 
-.emr-grid .row:not(.contact-info) {
-    grid-template-columns: repeat(2, 1fr);
+.stat-item {
+    background-color: var(--bg-secondary);
+    padding: var(--spacing-md);
+    border-radius: 8px;
+    text-align: center;
+    border: 1px solid var(--border-color);
 }
 
-.emr-grid .row.contact-info {
-    grid-template-columns: repeat(3, 1fr);
+.stat-value {
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: var(--primary-color);
+    margin-bottom: var(--spacing-xs);
 }
 
-.emr-field {
-    display: grid;
-    gap: 6px;
+.stat-label {
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
 }
 
-.emr-field label {
-    font-weight: 500;
-    color: var(--text-primary);
-    font-size: 0.9rem;
+/* Controls */
+.emr-controls {
+    background-color: var(--bg-primary);
+    border-bottom: 1px solid var(--border-color);
+    padding: var(--spacing-lg);
+    max-width: 1200px;
+    margin: 0 auto;
+}
+
+.search-container {
+    display: flex;
+    gap: var(--spacing-md);
+    margin-bottom: var(--spacing-md);
 }
 
-.emr-field input,
-.emr-field select,
-.emr-field textarea {
-    padding: 0.75rem;
+.search-input {
+    flex: 1;
+    padding: var(--spacing-md);
     border: 1px solid var(--border-color);
-    border-radius: 6px;
-    background-color: var(--bg-primary);
-    color: var(--text-primary);
-    font-size: 0.9rem;
+    border-radius: 8px;
+    font-size: 0.875rem;
     transition: border-color var(--transition-fast);
 }
 
-.emr-field input:focus,
-.emr-field select:focus,
-.emr-field textarea:focus {
+.search-input:focus {
     outline: none;
     border-color: var(--primary-color);
-    box-shadow: 0 0 0 2px rgba(var(--primary-color-rgb), 0.1);
+    box-shadow: 0 0 0 3px rgb(37 99 235 / 0.1);
 }
 
-.emr-field textarea {
-    resize: vertical;
-    min-height: 80px;
+.search-btn {
+    padding: var(--spacing-md) var(--spacing-lg);
+    background-color: var(--primary-color);
+    color: white;
+    border: none;
+    border-radius: 8px;
+    cursor: pointer;
+    transition: background-color var(--transition-fast);
 }
 
-/* Medications */
-.medications-container {
-    display: flex;
-    flex-direction: column;
-    gap: 1rem;
+.search-btn:hover {
+    background-color: var(--primary-hover);
 }
 
-.medications-list {
+.filter-container {
     display: flex;
-    flex-wrap: wrap;
-    gap: 0.5rem;
-    min-height: 40px;
-    padding: 0.5rem;
+    gap: var(--spacing-md);
+}
+
+.filter-select {
+    padding: var(--spacing-sm) var(--spacing-md);
     border: 1px solid var(--border-color);
     border-radius: 6px;
     background-color: var(--bg-primary);
+    font-size: 0.875rem;
+    cursor: pointer;
 }
 
-.medication-tag {
-    display: inline-flex;
-    align-items: center;
-    gap: 0.5rem;
-    background-color: var(--primary-color);
-    color: white;
-    padding: 0.25rem 0.75rem;
-    border-radius: 20px;
-    font-size: 0.8rem;
+/* Content */
+.emr-content {
+    max-width: 1200px;
+    margin: 0 auto;
+    padding: var(--spacing-lg);
+}
+
+/* Table */
+.emr-table-container {
+    background-color: var(--bg-primary);
+    border-radius: 12px;
+    border: 1px solid var(--border-color);
+    overflow: hidden;
+    box-shadow: var(--shadow-sm);
+}
+
+.emr-table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+.emr-table th {
+    background-color: var(--bg-tertiary);
+    padding: var(--spacing-md);
+    text-align: left;
+    font-weight: 600;
+    color: var(--text-primary);
+    border-bottom: 1px solid var(--border-color);
+    font-size: 0.875rem;
+}
+
+.emr-table td {
+    padding: var(--spacing-md);
+    border-bottom: 1px solid var(--border-color);
+    vertical-align: top;
+    font-size: 0.875rem;
+}
+
+.emr-table tbody tr:hover {
+    background-color: var(--bg-secondary);
+}
+
+.emr-table tbody tr:last-child td {
+    border-bottom: none;
+}
+
+/* EMR Entry Types */
+.emr-type {
+    display: inline-block;
+    padding: var(--spacing-xs) var(--spacing-sm);
+    border-radius: 4px;
+    font-size: 0.75rem;
     font-weight: 500;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
 }
 
-.medication-tag .remove-medication {
-    background: none;
-    border: none;
-    color: white;
-    cursor: pointer;
-    padding: 0;
-    margin-left: 0.25rem;
-    opacity: 0.7;
-    transition: opacity var(--transition-fast);
+.emr-type-diagnosis {
+    background-color: #fef3c7;
+    color: #92400e;
+}
+
+.emr-type-medication {
+    background-color: #dbeafe;
+    color: #1e40af;
 }
 
-.medication-tag .remove-medication:hover {
-    opacity: 1;
+.emr-type-vitals {
+    background-color: #f3e8ff;
+    color: #7c3aed;
 }
 
-.add-medication {
+.emr-type-lab {
+    background-color: #ecfdf5;
+    color: #065f46;
+}
+
+.emr-type-general {
+    background-color: var(--bg-tertiary);
+    color: var(--text-secondary);
+}
+
+/* Confidence Score */
+.confidence-score {
     display: flex;
-    gap: 0.5rem;
     align-items: center;
+    gap: var(--spacing-xs);
 }
 
-.add-medication input {
-    flex: 1;
-    margin: 0;
+.confidence-bar {
+    width: 60px;
+    height: 4px;
+    background-color: var(--bg-tertiary);
+    border-radius: 2px;
+    overflow: hidden;
+}
+
+.confidence-fill {
+    height: 100%;
+    transition: width var(--transition-normal);
 }
 
-.add-medication button {
-    white-space: nowrap;
+.confidence-fill.high {
+    background-color: var(--success-color);
 }
 
-/* Sessions */
-.sessions-container {
+.confidence-fill.medium {
+    background-color: var(--warning-color);
+}
+
+.confidence-fill.low {
+    background-color: var(--accent-color);
+}
+
+.confidence-text {
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+/* Action Buttons */
+.action-buttons {
     display: flex;
-    flex-direction: column;
-    gap: 1rem;
+    gap: var(--spacing-xs);
 }
 
-.session-item {
-    background-color: var(--bg-primary);
-    border: 1px solid var(--border-color);
-    border-radius: 6px;
-    padding: 1rem;
+.action-btn {
+    background: none;
+    border: none;
+    color: var(--text-muted);
     cursor: pointer;
+    padding: var(--spacing-xs);
+    border-radius: 4px;
     transition: all var(--transition-fast);
+    font-size: 0.875rem;
 }
 
-.session-item:hover {
-    border-color: var(--primary-color);
+.action-btn:hover {
     background-color: var(--bg-tertiary);
+    color: var(--primary-color);
 }
 
-.session-title {
-    font-weight: 600;
+.action-btn.danger:hover {
+    color: var(--accent-color);
+}
+
+/* Loading and Empty States */
+.loading-state, .empty-state {
+    text-align: center;
+    padding: var(--spacing-2xl);
+    background-color: var(--bg-primary);
+    border-radius: 12px;
+    border: 1px solid var(--border-color);
+}
+
+.loading-spinner {
+    font-size: 2rem;
+    color: var(--primary-color);
+    margin-bottom: var(--spacing-md);
+}
+
+.empty-icon {
+    font-size: 3rem;
+    color: var(--text-muted);
+    margin-bottom: var(--spacing-lg);
+}
+
+.empty-state h3 {
+    margin: 0 0 var(--spacing-md) 0;
     color: var(--text-primary);
-    margin-bottom: 0.5rem;
 }
 
-.session-meta {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    font-size: 0.8rem;
+.empty-state p {
+    margin: 0 0 var(--spacing-lg) 0;
     color: var(--text-secondary);
 }
 
-.session-date {
-    font-family: monospace;
+/* EMR Detail Modal */
+.emr-detail-modal {
+    max-width: 800px;
+    max-height: 80vh;
+    overflow-y: auto;
 }
 
-.session-messages {
-    color: var(--text-secondary);
+.emr-detail-section {
+    margin-bottom: var(--spacing-lg);
 }
 
-/* Actions */
-.emr-actions {
-    display: flex;
-    gap: 1rem;
-    flex-wrap: wrap;
+.emr-detail-section h4 {
+    margin: 0 0 var(--spacing-md) 0;
+    color: var(--text-primary);
+    font-size: 1rem;
+    border-bottom: 1px solid var(--border-color);
+    padding-bottom: var(--spacing-sm);
 }
 
-.btn-primary,
-.btn-secondary {
-    display: inline-flex;
-    align-items: center;
-    gap: 0.5rem;
-    padding: 0.75rem 1.5rem;
-    border: none;
-    border-radius: 6px;
-    font-size: 0.9rem;
-    font-weight: 500;
-    cursor: pointer;
-    transition: all var(--transition-fast);
-    text-decoration: none;
+.emr-detail-list {
+    list-style: none;
+    padding: 0;
+    margin: 0;
 }
 
-.btn-primary {
-    background-color: var(--primary-color);
-    color: white;
+.emr-detail-list li {
+    padding: var(--spacing-sm) 0;
+    border-bottom: 1px solid var(--bg-tertiary);
 }
 
-.btn-primary:hover {
-    background-color: var(--primary-color-dark);
-    transform: translateY(-1px);
+.emr-detail-list li:last-child {
+    border-bottom: none;
 }
 
-.btn-secondary {
-    background-color: var(--bg-tertiary);
+.medication-item {
+    background-color: var(--bg-secondary);
+    padding: var(--spacing-md);
+    border-radius: 8px;
+    margin-bottom: var(--spacing-sm);
+    border: 1px solid var(--border-color);
+}
+
+.medication-name {
+    font-weight: 600;
     color: var(--text-primary);
+    margin-bottom: var(--spacing-xs);
+}
+
+.medication-details {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+}
+
+.vital-signs-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+    gap: var(--spacing-md);
+}
+
+.vital-sign-item {
+    background-color: var(--bg-secondary);
+    padding: var(--spacing-md);
+    border-radius: 8px;
+    text-align: center;
     border: 1px solid var(--border-color);
 }
 
-.btn-secondary:hover {
-    background-color: var(--bg-primary);
-    border-color: var(--primary-color);
+.vital-sign-label {
+    font-size: 0.75rem;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    margin-bottom: var(--spacing-xs);
 }
 
-/* Loading States */
-.loading {
-    opacity: 0.6;
-    pointer-events: none;
+.vital-sign-value {
+    font-size: 1.125rem;
+    font-weight: 600;
+    color: var(--text-primary);
 }
 
 /* Responsive Design */
 @media (max-width: 768px) {
     .emr-header-content {
         flex-direction: column;
+        gap: var(--spacing-md);
         align-items: stretch;
-        text-align: center;
     }
 
-    .patient-info-header {
-        align-items: center;
+    .emr-actions {
+        justify-content: center;
+    }
+
+    .patient-info {
+        flex-direction: column;
         text-align: center;
     }
 
-    .emr-main {
-        padding: 1rem;
+    .patient-stats {
+        grid-template-columns: repeat(2, 1fr);
     }
 
-    .emr-grid {
-        grid-template-columns: 1fr;
+    .search-container {
+        flex-direction: column;
     }
 
-    .emr-actions {
+    .filter-container {
         flex-direction: column;
     }
 
-    .add-medication {
+    .emr-table-container {
+        overflow-x: auto;
+    }
+
+    .emr-table {
+        min-width: 600px;
+    }
+
+    .action-buttons {
         flex-direction: column;
-        align-items: stretch;
     }
 }
 
-@media (max-width: 720px) {
-    .emr-grid .row,
-    .emr-grid .row.contact-info {
-        grid-template-columns: 1fr;
+/* Dark Theme Support */
+@media (prefers-color-scheme: dark) {
+    .emr-container {
+        background-color: var(--dark-bg-secondary);
     }
-}
 
-/* Dark Theme Adjustments */
-[data-theme="dark"] .emr-field input,
-[data-theme="dark"] .emr-field select,
-[data-theme="dark"] .emr-field textarea {
-    background-color: var(--bg-secondary);
-}
+    .emr-header {
+        background-color: var(--dark-bg-primary);
+        border-bottom-color: var(--dark-border-color);
+    }
 
-[data-theme="dark"] .medications-list {
-    background-color: var(--bg-secondary);
-}
+    .emr-title h1 {
+        color: var(--dark-text-primary);
+    }
 
-[data-theme="dark"] .session-item {
-    background-color: var(--bg-secondary);
-}
+    .patient-info-bar {
+        background-color: var(--dark-bg-primary);
+        border-bottom-color: var(--dark-border-color);
+    }
+
+    .patient-details h3 {
+        color: var(--dark-text-primary);
+    }
+
+    .patient-details p {
+        color: var(--dark-text-secondary);
+    }
+
+    .emr-controls {
+        background-color: var(--dark-bg-primary);
+        border-bottom-color: var(--dark-border-color);
+    }
+
+    .search-input, .filter-select {
+        background-color: var(--dark-bg-secondary);
+        border-color: var(--dark-border-color);
+        color: var(--dark-text-primary);
+    }
+
+    .emr-table-container {
+        background-color: var(--dark-bg-primary);
+        border-color: var(--dark-border-color);
+    }
+
+    .emr-table th {
+        background-color: var(--dark-bg-tertiary);
+        color: var(--dark-text-primary);
+        border-bottom-color: var(--dark-border-color);
+    }
+
+    .emr-table td {
+        border-bottom-color: var(--dark-border-color);
+        color: var(--dark-text-primary);
+    }
+
+    .emr-table tbody tr:hover {
+        background-color: var(--dark-bg-secondary);
+    }
+}

static/css/styles.css

@@ -481,6 +481,96 @@ body {
     text-align: right;
 }
 
+/* EMR Button Styles */
+.message-actions {
+    display: flex;
+    align-items: center;
+    margin-left: var(--spacing-sm);
+    opacity: 0;
+    transition: opacity var(--transition-fast);
+}
+
+.message:hover .message-actions {
+    opacity: 1;
+}
+
+.emr-extract-btn {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    cursor: pointer;
+    padding: var(--spacing-sm);
+    border-radius: 6px;
+    transition: all var(--transition-fast);
+    font-size: 0.875rem;
+}
+
+.emr-extract-btn:hover {
+    background-color: var(--bg-tertiary);
+    color: var(--primary-color);
+    transform: scale(1.1);
+}
+
+.emr-extract-btn:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+    transform: none;
+}
+
+/* Notification Styles */
+.notification {
+    position: fixed;
+    top: var(--spacing-lg);
+    right: var(--spacing-lg);
+    background-color: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    box-shadow: var(--shadow-lg);
+    padding: var(--spacing-md);
+    z-index: 1000;
+    transform: translateX(100%);
+    transition: transform var(--transition-normal);
+    max-width: 300px;
+}
+
+.notification.show {
+    transform: translateX(0);
+}
+
+.notification-content {
+    display: flex;
+    align-items: center;
+    gap: var(--spacing-sm);
+}
+
+.notification-success {
+    border-left: 4px solid var(--success-color);
+}
+
+.notification-error {
+    border-left: 4px solid var(--accent-color);
+}
+
+.notification-info {
+    border-left: 4px solid var(--primary-color);
+}
+
+.notification-content i {
+    font-size: 1.125rem;
+}
+
+.notification-success .notification-content i {
+    color: var(--success-color);
+}
+
+.notification-error .notification-content i {
+    color: var(--accent-color);
+}
+
+.notification-info .notification-content i {
+    color: var(--primary-color);
+}
+
 /* Chat Input */
 .chat-input-container {
     padding: var(--spacing-lg);

static/emr.html

@@ -3,139 +3,164 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Patient EMR - Medical AI Assistant</title>
+    <title>EMR - Medical AI Assistant</title>
+    <link rel="icon" type="image/svg+xml" href="/static/icon.svg">
     <link rel="stylesheet" href="/static/css/styles.css">
     <link rel="stylesheet" href="/static/css/emr.css">
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
 </head>
 <body>
     <div class="emr-container">
         <!-- Header -->
-        <header class="emr-header">
+        <div class="emr-header">
             <div class="emr-header-content">
-                <a href="/" class="back-link">
-                    <i class="fas fa-arrow-left"></i>
-                    Back to Assistant
-                </a>
-                <h1>Patient EMR</h1>
-                <div class="patient-info-header" id="patientInfoHeader">
-                    <span class="patient-name" id="patientName">Loading...</span>
-                    <span class="patient-id" id="patientId">Loading...</span>
+                <div class="emr-title">
+                    <i class="fas fa-file-medical"></i>
+                    <h1>Electronic Medical Records</h1>
+                </div>
+                <div class="emr-actions">
+                    <button class="btn btn-secondary" id="refreshBtn">
+                        <i class="fas fa-sync-alt"></i>
+                        Refresh
+                    </button>
+                    <button class="btn btn-primary" id="searchBtn">
+                        <i class="fas fa-search"></i>
+                        Search
+                    </button>
+                    <a href="/static/index.html" class="btn btn-outline">
+                        <i class="fas fa-arrow-left"></i>
+                        Back to Chat
+                    </a>
                 </div>
             </div>
-        </header>
+        </div>
 
-        <!-- Main Content -->
-        <main class="emr-main">
-            <!-- Patient Overview -->
-            <section class="emr-section">
-                <h2><i class="fas fa-user"></i> Patient Overview</h2>
-                <div class="emr-grid">
-                    <!-- Row 1: Name and Age -->
-                    <div class="row">
-                        <div class="emr-field">
-                            <label>Full Name</label>
-                            <input type="text" id="patientNameInput" placeholder="Enter patient name">
-                        </div>
-                        <div class="emr-field">
-                            <label>Age</label>
-                            <input type="number" id="patientAgeInput" placeholder="Enter age" min="0" max="150">
-                        </div>
-                    </div>
-                    <!-- Row 2: Sex and Ethnicity -->
-                    <div class="row">
-                        <div class="emr-field">
-                            <label>Sex</label>
-                            <select id="patientSexInput">
-                                <option value="Male">Male</option>
-                                <option value="Female">Female</option>
-                                <option value="Intersex">Intersex</option>
-                            </select>
-                        </div>
-                        <div class="emr-field">
-                            <label>Ethnicity</label>
-                            <input type="ethnicity" id="patientEthnicityInput" placeholder="Enter ethnicity">
-                        </div>
-                    </div>
-                    <!-- Row 3: Contact Information -->
-                    <div class="row contact-info">
-                        <div class="emr-field">
-                            <label>Phone</label>
-                            <input type="tel" id="patientPhoneInput" placeholder="Enter phone number">
-                        </div>
-                        <div class="emr-field">
-                            <label>Email</label>
-                            <input type="email" id="patientEmailInput" placeholder="Enter email address">
-                        </div>
-                        <div class="emr-field">
-                            <label>Address</label>
-                            <input type="text" id="patientAddressInput" placeholder="Enter full address">
-                        </div>
-                    </div>
+        <!-- Patient Info Bar -->
+        <div class="patient-info-bar" id="patientInfoBar" style="display: none;">
+            <div class="patient-info">
+                <div class="patient-avatar">
+                    <i class="fas fa-user"></i>
+                </div>
+                <div class="patient-details">
+                    <h3 id="patientName">Patient Name</h3>
+                    <p id="patientDetails">Age: -- | Sex: -- | ID: --</p>
                 </div>
-            </section>
+            </div>
+            <div class="patient-stats" id="patientStats">
+                <!-- Stats will be populated here -->
+            </div>
+        </div>
 
-            <!-- Medical Information -->
-            <section class="emr-section">
-                <h2><i class="fas fa-pills"></i> Medical Information</h2>
-                <div class="emr-grid">
-                    <div class="row">
-                        <div class="emr-field">
-                            <label>Current Medications</label>
-                            <div class="medications-container">
-                                <div class="medications-list" id="medicationsList">
-                                    <!-- Medications will be added here dynamically -->
-                                </div>
-                                <div class="add-medication">
-                                    <input type="text" id="newMedicationInput" placeholder="Add new medication">
-                                    <button id="addMedicationBtn" class="btn-secondary">
-                                        <i class="fas fa-plus"></i> Add
-                                    </button>
-                                </div>
-                            </div>
-                        </div>
-                        <div class="emr-field">
-                            <label>Past Assessment Summary</label>
-                            <textarea id="pastAssessmentInput" placeholder="Enter past assessment summary" rows="4"></textarea>
-                        </div>
-                    </div>
+        <!-- Search and Filters -->
+        <div class="emr-controls">
+            <div class="search-container">
+                <input type="text" id="searchInput" placeholder="Search EMR entries..." class="search-input">
+                <button class="search-btn" id="searchButton">
+                    <i class="fas fa-search"></i>
+                </button>
+            </div>
+            <div class="filter-container">
+                <select id="dateFilter" class="filter-select">
+                    <option value="all">All Time</option>
+                    <option value="today">Today</option>
+                    <option value="week">This Week</option>
+                    <option value="month">This Month</option>
+                </select>
+                <select id="typeFilter" class="filter-select">
+                    <option value="all">All Types</option>
+                    <option value="diagnosis">Diagnosis</option>
+                    <option value="medication">Medication</option>
+                    <option value="vitals">Vital Signs</option>
+                    <option value="lab">Lab Results</option>
+                </select>
+            </div>
+        </div>
+
+        <!-- EMR Entries Table -->
+        <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>
+
+            <!-- Loading State -->
+            <div class="loading-state" id="loadingState" style="display: none;">
+                <div class="loading-spinner">
+                    <i class="fas fa-spinner fa-spin"></i>
                 </div>
-            </section>
+                <p>Loading EMR data...</p>
+            </div>
 
-            <!-- Recent Sessions -->
-            <section class="emr-section">
-                <h2><i class="fas fa-comments"></i> Recent Chat Sessions</h2>
-                <div class="sessions-container" id="sessionsContainer">
-                    <!-- Sessions will be loaded here -->
+            <!-- Empty State -->
+            <div class="empty-state" id="emptyState" style="display: none;">
+                <div class="empty-icon">
+                    <i class="fas fa-file-medical"></i>
                 </div>
-            </section>
+                <h3>No EMR Data Found</h3>
+                <p>No medical records found for this patient. EMR data will appear here when you extract information from chat messages.</p>
+                <a href="/static/index.html" class="btn btn-primary">
+                    <i class="fas fa-comments"></i>
+                    Go to Chat
+                </a>
+            </div>
+        </div>
 
-            <!-- Actions -->
-            <section class="emr-section">
-                <h2><i class="fas fa-cog"></i> Actions</h2>
-                <div class="emr-actions">
-                    <button id="savePatientBtn" class="btn-primary">
-                        <i class="fas fa-save"></i> Save Changes
-                    </button>
-                    <button id="refreshPatientBtn" class="btn-secondary">
-                        <i class="fas fa-refresh"></i> Refresh Data
-                    </button>
-                    <button id="exportPatientBtn" class="btn-secondary">
-                        <i class="fas fa-download"></i> Export EMR
-                    </button>
+        <!-- EMR Detail Modal -->
+        <div class="modal" id="emrDetailModal">
+            <div class="modal-content emr-detail-modal">
+                <div class="modal-header">
+                    <h3>EMR Entry Details</h3>
+                    <button class="modal-close" id="emrDetailModalClose">&times;</button>
                 </div>
-            </section>
-        </main>
-    </div>
+                <div class="modal-body" id="emrDetailContent">
+                    <!-- EMR details will be populated here -->
+                </div>
+                <div class="modal-footer">
+                    <button class="btn btn-secondary" id="emrDetailModalCancel">Close</button>
+                    <button class="btn btn-danger" id="deleteEmrBtn" style="display: none;">Delete Entry</button>
+                </div>
+            </div>
+        </div>
 
-    <!-- Loading Overlay -->
-    <div class="loading-overlay" id="loadingOverlay">
-        <div class="loading-spinner">
-            <i class="fas fa-spinner fa-spin"></i>
-            <div>Loading...</div>
+        <!-- Search Modal -->
+        <div class="modal" id="searchModal">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h3>Advanced Search</h3>
+                    <button class="modal-close" id="searchModalClose">&times;</button>
+                </div>
+                <div class="modal-body">
+                    <div class="form-group">
+                        <label for="semanticSearchInput">Search by meaning (semantic search):</label>
+                        <input type="text" id="semanticSearchInput" placeholder="e.g., 'chest pain treatment' or 'diabetes medication'">
+                    </div>
+                    <div class="form-group">
+                        <label for="exactSearchInput">Search by exact text:</label>
+                        <input type="text" id="exactSearchInput" placeholder="e.g., 'hypertension' or 'metformin'">
+                    </div>
+                </div>
+                <div class="modal-footer">
+                    <button class="btn btn-secondary" id="searchModalCancel">Cancel</button>
+                    <button class="btn btn-primary" id="performSearchBtn">Search</button>
+                </div>
+            </div>
         </div>
     </div>
 
     <script src="/static/js/emr.js"></script>
 </body>
-</html>
+</html>

static/index.html

@@ -50,7 +50,7 @@
                 </div>
                 <div class="patient-status" id="patientStatus">No patient selected</div>
                 <div class="patient-actions" id="patientActions" style="display: none;">
-                    <a href="#" id="emrLink" class="emr-link">
+                    <a href="/static/emr.html" id="emrLink" class="emr-link">
                         <i class="fas fa-file-medical"></i> EMR
                     </a>
                 </div>

static/js/app.js

@@ -1830,15 +1830,30 @@ How can I assist you today?`;
         messageElement.id = `message-${message.id}`;
         const avatar = message.role === 'user' ? '<i class="fas fa-user"></i>' : '<i class="fas fa-robot"></i>';
         const time = this.formatTime(message.timestamp);
+        
+        // Add EMR icon for assistant messages (system-generated)
+        const emrIcon = message.role === 'assistant' ? 
+            `<div class="message-actions">
+                <button class="emr-extract-btn" onclick="app.extractEMR('${message.id}')" title="Extract to EMR" data-message-id="${message.id}">
+                    <i class="fas fa-file-medical"></i>
+                </button>
+            </div>` : '';
+        
         messageElement.innerHTML = `
             <div class="message-avatar">${avatar}</div>
             <div class="message-content">
                 <div class="message-text">${this.formatMessageContent(message.content)}</div>
                 <div class="message-time">${time}</div>
-            </div>`;
+            </div>
+            ${emrIcon}`;
         chatMessages.appendChild(messageElement);
         chatMessages.scrollTop = chatMessages.scrollHeight;
         if (this.currentSession) this.currentSession.lastActivity = new Date().toISOString();
+        
+        // Check EMR status for assistant messages
+        if (message.role === 'assistant' && this.currentPatientId) {
+            this.checkEMRStatus(message.id);
+        }
     }
 
     formatMessageContent(content) {
@@ -1871,6 +1886,129 @@ How can I assist you today?`;
         if (diff < 86400000) { const hours = Math.floor(diff / 3600000); return `${hours} hour${hours > 1 ? 's' : ''} ago`; }
         return date.toLocaleDateString();
     }
+
+    async extractEMR(messageId) {
+        try {
+            // Check if patient is selected
+            if (!this.currentPatientId) {
+                alert('Please select a patient before extracting EMR data.');
+                return;
+            }
+
+            // Check if doctor is logged in
+            if (!this.currentUser) {
+                alert('Please log in as a doctor before extracting EMR data.');
+                return;
+            }
+
+            // Find the message
+            const message = this.currentSession?.messages?.find(m => m.id === messageId);
+            if (!message) {
+                console.error('Message not found:', messageId);
+                return;
+            }
+
+            // Show loading state
+            const button = document.querySelector(`[onclick="app.extractEMR('${messageId}')"]`);
+            if (button) {
+                button.disabled = true;
+                button.innerHTML = '<i class="fas fa-spinner fa-spin"></i>';
+            }
+
+            // Call EMR extraction API
+            const response = await fetch('/emr/extract', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    patient_id: this.currentPatientId,
+                    doctor_id: this.currentUser.id || 'default-doctor',
+                    message_id: messageId,
+                    session_id: this.currentSession?.id || 'default-session',
+                    message: message.content
+                })
+            });
+
+            if (response.ok) {
+                const result = await response.json();
+                console.log('EMR extraction successful:', result);
+                
+                // Show success message
+                if (button) {
+                    button.innerHTML = '<i class="fas fa-check"></i>';
+                    button.style.color = 'var(--success-color)';
+                    setTimeout(() => {
+                        button.innerHTML = '<i class="fas fa-file-medical"></i>';
+                        button.style.color = '';
+                        button.disabled = false;
+                    }, 2000);
+                }
+                
+                // Show notification
+                this.showNotification('EMR data extracted successfully!', 'success');
+            } else {
+                const errorData = await response.json().catch(() => ({ detail: 'Unknown error' }));
+                const errorMessage = errorData.detail || `HTTP ${response.status}: ${response.statusText}`;
+                throw new Error(errorMessage);
+            }
+
+        } catch (error) {
+            console.error('Error extracting EMR:', error);
+            
+            // Reset button state
+            const button = document.querySelector(`[onclick="app.extractEMR('${messageId}')"]`);
+            if (button) {
+                button.innerHTML = '<i class="fas fa-file-medical"></i>';
+                button.disabled = false;
+            }
+            
+            // Show error message
+            this.showNotification('Failed to extract EMR data. Please try again.', 'error');
+        }
+    }
+
+    async checkEMRStatus(messageId) {
+        try {
+            const response = await fetch(`/emr/check/${messageId}`);
+            if (response.ok) {
+                const result = await response.json();
+                const button = document.querySelector(`[data-message-id="${messageId}"]`);
+                if (button && result.emr_exists) {
+                    button.innerHTML = '<i class="fas fa-check"></i>';
+                    button.style.color = 'var(--success-color)';
+                    button.title = 'EMR data already extracted';
+                    button.disabled = true;
+                }
+            }
+        } catch (error) {
+            console.warn('Could not check EMR status:', error);
+        }
+    }
+
+    showNotification(message, type = 'info') {
+        // Create notification element
+        const notification = document.createElement('div');
+        notification.className = `notification notification-${type}`;
+        notification.innerHTML = `
+            <div class="notification-content">
+                <i class="fas fa-${type === 'success' ? 'check-circle' : type === 'error' ? 'exclamation-circle' : 'info-circle'}"></i>
+                <span>${message}</span>
+            </div>
+        `;
+        
+        // Add to page
+        document.body.appendChild(notification);
+        
+        // Show notification
+        setTimeout(() => notification.classList.add('show'), 100);
+        
+        // Remove after 3 seconds
+        setTimeout(() => {
+            notification.classList.remove('show');
+            setTimeout(() => notification.remove(), 300);
+        }, 3000);
+    }
 }
 // ----------------------------------------------------------
 // Additional UI setup END

static/js/emr.js

@@ -1,291 +1,564 @@
 // EMR Page JavaScript
-class PatientEMR {
+// static/js/emr.js
+
+class EMRPage {
     constructor() {
-        this.patientId = null;
-        this.patientData = null;
-        this.medications = [];
-        this.sessions = [];
+        this.currentPatientId = null;
+        this.currentPatient = null;
+        this.emrEntries = [];
+        this.filteredEntries = [];
+        this.currentPage = 1;
+        this.entriesPerPage = 20;
 
         this.init();
     }
 
     async init() {
-        // Get patient ID from URL or localStorage
-        this.patientId = this.getPatientIdFromURL() || localStorage.getItem('medicalChatbotPatientId');
-
-        if (!this.patientId) {
-            this.showError('No patient selected. Please go back to the main page and select a patient.');
-            return;
-        }
-
         this.setupEventListeners();
-        await this.loadPatientData();
-    }
-
-    getPatientIdFromURL() {
-        const urlParams = new URLSearchParams(window.location.search);
-        return urlParams.get('patient_id');
+        await this.loadPatientFromURL();
+        if (this.currentPatientId) {
+            await this.loadEMRData();
+            await this.loadPatientStats();
+        } else {
+            this.showEmptyState();
+        }
     }
 
     setupEventListeners() {
-        // Save button
-        document.getElementById('savePatientBtn').addEventListener('click', () => {
-            this.savePatientData();
+        // Refresh button
+        document.getElementById('refreshBtn').addEventListener('click', () => {
+            this.loadEMRData();
         });
 
-        // Refresh button
-        document.getElementById('refreshPatientBtn').addEventListener('click', () => {
-            this.loadPatientData();
+        // Search button
+        document.getElementById('searchBtn').addEventListener('click', () => {
+            this.openSearchModal();
         });
 
-        // Export button
-        document.getElementById('exportPatientBtn').addEventListener('click', () => {
-            this.exportPatientData();
+        // Search input
+        document.getElementById('searchInput').addEventListener('input', (e) => {
+            this.filterEntries(e.target.value);
         });
 
-        // Add medication button
-        document.getElementById('addMedicationBtn').addEventListener('click', () => {
-            this.addMedication();
+        // Filter selects
+        document.getElementById('dateFilter').addEventListener('change', () => {
+            this.applyFilters();
         });
 
-        // Add medication on Enter key
-        document.getElementById('newMedicationInput').addEventListener('keydown', (e) => {
-            if (e.key === 'Enter') {
-                this.addMedication();
-            }
+        document.getElementById('typeFilter').addEventListener('change', () => {
+            this.applyFilters();
         });
+
+        // Modal handlers
+        this.setupModalHandlers();
     }
 
-    async loadPatientData() {
-        this.showLoading(true);
+    setupModalHandlers() {
+        // EMR Detail Modal
+        const emrDetailModal = document.getElementById('emrDetailModal');
+        const emrDetailModalClose = document.getElementById('emrDetailModalClose');
+        const emrDetailModalCancel = document.getElementById('emrDetailModalCancel');
 
+        if (emrDetailModalClose) {
+            emrDetailModalClose.addEventListener('click', () => {
+                emrDetailModal.classList.remove('show');
+            });
+        }
+
+        if (emrDetailModalCancel) {
+            emrDetailModalCancel.addEventListener('click', () => {
+                emrDetailModal.classList.remove('show');
+            });
+        }
+
+        // Search Modal
+        const searchModal = document.getElementById('searchModal');
+        const searchModalClose = document.getElementById('searchModalClose');
+        const searchModalCancel = document.getElementById('searchModalCancel');
+        const performSearchBtn = document.getElementById('performSearchBtn');
+
+        if (searchModalClose) {
+            searchModalClose.addEventListener('click', () => {
+                searchModal.classList.remove('show');
+            });
+        }
+
+        if (searchModalCancel) {
+            searchModalCancel.addEventListener('click', () => {
+                searchModal.classList.remove('show');
+            });
+        }
+
+        if (performSearchBtn) {
+            performSearchBtn.addEventListener('click', () => {
+                this.performAdvancedSearch();
+                searchModal.classList.remove('show');
+            });
+        }
+    }
+
+    async loadPatientFromURL() {
+        const urlParams = new URLSearchParams(window.location.search);
+        const patientId = urlParams.get('patient_id');
+
+        if (patientId) {
+            this.currentPatientId = patientId;
+            await this.loadPatientInfo();
+        } else {
+            // Try to get from localStorage
+            const savedPatientId = localStorage.getItem('medicalChatbotPatientId');
+            if (savedPatientId) {
+                this.currentPatientId = savedPatientId;
+                await this.loadPatientInfo();
+            }
+        }
+    }
+
+    async loadPatientInfo() {
         try {
-            // Load patient data
-            const patientResp = await fetch(`/patient/${this.patientId}`);
-            if (!patientResp.ok) {
-                throw new Error('Failed to load patient data');
+            const response = await fetch(`/patient/${this.currentPatientId}`);
+            if (response.ok) {
+                this.currentPatient = await response.json();
+                this.updatePatientInfoBar();
+            } else {
+                console.error('Failed to load patient info');
+                this.showEmptyState();
             }
+        } catch (error) {
+            console.error('Error loading patient info:', error);
+            this.showEmptyState();
+        }
+    }
 
-            this.patientData = await patientResp.json();
-            this.populatePatientForm();
+    updatePatientInfoBar() {
+        if (!this.currentPatient) return;
 
-            // Load patient sessions
-            await this.loadPatientSessions();
+        const patientInfoBar = document.getElementById('patientInfoBar');
+        const patientName = document.getElementById('patientName');
+        const patientDetails = document.getElementById('patientDetails');
+
+        patientName.textContent = this.currentPatient.name;
+        patientDetails.textContent = `Age: ${this.currentPatient.age} | Sex: ${this.currentPatient.sex} | ID: ${this.currentPatient._id}`;
+
+        patientInfoBar.style.display = 'block';
+    }
 
+    async loadPatientStats() {
+        try {
+            const response = await fetch(`/emr/statistics/${this.currentPatientId}`);
+            if (response.ok) {
+                const stats = await response.json();
+                this.updatePatientStats(stats);
+            }
         } catch (error) {
-            console.error('Error loading patient data:', error);
-            this.showError('Failed to load patient data. Please try again.');
-        } finally {
-            this.showLoading(false);
+            console.error('Error loading patient stats:', error);
         }
     }
 
-    populatePatientForm() {
-        if (!this.patientData) return;
-
-        // Update header
-        document.getElementById('patientName').textContent = this.patientData.name || 'Unknown';
-        document.getElementById('patientId').textContent = `ID: ${this.patientData._id}`;
-
-        // Populate form fields
-        document.getElementById('patientNameInput').value = this.patientData.name || '';
-        document.getElementById('patientAgeInput').value = this.patientData.age || '';
-        document.getElementById('patientSexInput').value = this.patientData.sex || '';
-        document.getElementById('patientEthnicityInput').value = this.patientData.ethnicity || '';
-        document.getElementById('patientPhoneInput').value = this.patientData.phone || '';
-        document.getElementById('patientEmailInput').value = this.patientData.email || '';
-        document.getElementById('patientAddressInput').value = this.patientData.address || '';
-        document.getElementById('pastAssessmentInput').value = this.patientData.past_assessment_summary || '';
-
-        // Populate medications
-        this.medications = this.patientData.medications || [];
-        this.renderMedications();
+    updatePatientStats(stats) {
+        const patientStats = document.getElementById('patientStats');
+
+        patientStats.innerHTML = `
+            <div class="stat-item">
+                <div class="stat-value">${stats.total_entries || 0}</div>
+                <div class="stat-label">Total Entries</div>
+            </div>
+            <div class="stat-item">
+                <div class="stat-value">${Math.round((stats.avg_confidence || 0) * 100)}%</div>
+                <div class="stat-label">Avg Confidence</div>
+            </div>
+            <div class="stat-item">
+                <div class="stat-value">${stats.diagnosis_count || 0}</div>
+                <div class="stat-label">Diagnoses</div>
+            </div>
+            <div class="stat-item">
+                <div class="stat-value">${stats.medication_count || 0}</div>
+                <div class="stat-label">Medications</div>
+            </div>
+        `;
+    }
+
+    async loadEMRData() {
+        if (!this.currentPatientId) return;
+
+        this.showLoading(true);
+
+        try {
+            const response = await fetch(`/emr/patient/${this.currentPatientId}?limit=100`);
+            if (response.ok) {
+                this.emrEntries = await response.json();
+                this.filteredEntries = [...this.emrEntries];
+                this.renderEMRTable();
+            } else {
+                console.error('Failed to load EMR data');
+                this.showEmptyState();
+            }
+        } catch (error) {
+            console.error('Error loading EMR data:', error);
+            this.showErrorState('Failed to load EMR data. Please try again.');
+        } finally {
+            this.showLoading(false);
+        }
     }
 
-    renderMedications() {
-        const container = document.getElementById('medicationsList');
-        container.innerHTML = '';
+    renderEMRTable() {
+        const tableBody = document.getElementById('emrTableBody');
 
-        if (this.medications.length === 0) {
-            container.innerHTML = '<div style="color: var(--text-secondary); font-style: italic;">No medications listed</div>';
+        if (this.filteredEntries.length === 0) {
+            this.showEmptyState();
             return;
         }
 
-        this.medications.forEach((medication, index) => {
-            const tag = document.createElement('div');
-            tag.className = 'medication-tag';
-            tag.innerHTML = `
-                ${medication}
-                <button class="remove-medication" data-index="${index}">
-                    <i class="fas fa-times"></i>
+        tableBody.innerHTML = this.filteredEntries.map(entry => {
+            const date = new Date(entry.created_at).toLocaleString();
+            const type = this.getEMRType(entry.extracted_data);
+            const diagnosis = entry.extracted_data.diagnosis?.slice(0, 2).join(', ') || '-';
+            const medications = entry.extracted_data.medications?.slice(0, 2).map(m => m.name).join(', ') || '-';
+            const vitals = this.formatVitalSigns(entry.extracted_data.vital_signs);
+            const confidence = this.formatConfidence(entry.confidence_score);
+
+            return `
+                <tr>
+                    <td>${date}</td>
+                    <td><span class="emr-type emr-type-${type}">${type}</span></td>
+                    <td>${diagnosis}</td>
+                    <td>${medications}</td>
+                    <td>${vitals}</td>
+                    <td>${confidence}</td>
+                    <td>
+                        <div class="action-buttons">
+                            <button class="action-btn" onclick="emrPage.viewEMRDetail('${entry.emr_id}')" title="View Details">
+                                <i class="fas fa-eye"></i>
+                            </button>
+                            <button class="action-btn danger" onclick="emrPage.deleteEMREntry('${entry.emr_id}')" title="Delete">
+                                <i class="fas fa-trash"></i>
                 </button>
+                        </div>
+                    </td>
+                </tr>
             `;
-            container.appendChild(tag);
-        });
+        }).join('');
+    }
 
-        // Add event listeners for remove buttons
-        container.querySelectorAll('.remove-medication').forEach(btn => {
-            btn.addEventListener('click', (e) => {
-                const index = parseInt(e.target.closest('.remove-medication').dataset.index);
-                this.removeMedication(index);
-            });
-        });
+    getEMRType(extractedData) {
+        if (extractedData.diagnosis?.length > 0) return 'diagnosis';
+        if (extractedData.medications?.length > 0) return 'medication';
+        if (extractedData.vital_signs && Object.values(extractedData.vital_signs).some(v => v)) return 'vitals';
+        if (extractedData.lab_results?.length > 0) return 'lab';
+        return 'general';
     }
 
-    addMedication() {
-        const input = document.getElementById('newMedicationInput');
-        const medication = input.value.trim();
+    formatVitalSigns(vitalSigns) {
+        if (!vitalSigns) return '-';
 
-        if (!medication) return;
+        const vitals = [];
+        if (vitalSigns.blood_pressure) vitals.push(`BP: ${vitalSigns.blood_pressure}`);
+        if (vitalSigns.heart_rate) vitals.push(`HR: ${vitalSigns.heart_rate}`);
+        if (vitalSigns.temperature) vitals.push(`Temp: ${vitalSigns.temperature}`);
 
-        this.medications.push(medication);
-        this.renderMedications();
-        input.value = '';
+        return vitals.length > 0 ? vitals.join(', ') : '-';
     }
 
-    removeMedication(index) {
-        this.medications.splice(index, 1);
-        this.renderMedications();
+    formatConfidence(score) {
+        const percentage = Math.round(score * 100);
+        const level = score >= 0.8 ? 'high' : score >= 0.6 ? 'medium' : 'low';
+
+        return `
+            <div class="confidence-score">
+                <div class="confidence-bar">
+                    <div class="confidence-fill ${level}" style="width: ${percentage}%"></div>
+                </div>
+                <span class="confidence-text">${percentage}%</span>
+            </div>
+        `;
     }
 
-    async loadPatientSessions() {
+    async viewEMRDetail(emrId) {
         try {
-            const resp = await fetch(`/patient/${this.patientId}/session`);
-            if (resp.ok) {
-                const data = await resp.json();
-                this.sessions = data.sessions || [];
-                this.renderSessions();
+            const response = await fetch(`/emr/${emrId}`);
+            if (response.ok) {
+                const entry = await response.json();
+                this.showEMRDetailModal(entry);
+            } else {
+                alert('Failed to load EMR details');
             }
         } catch (error) {
-            console.error('Error loading sessions:', error);
+            console.error('Error loading EMR detail:', error);
+            alert('Error loading EMR details');
         }
     }
 
-    renderSessions() {
-        const container = document.getElementById('sessionsContainer');
+    showEMRDetailModal(entry) {
+        const modal = document.getElementById('emrDetailModal');
+        const content = document.getElementById('emrDetailContent');
+
+        const date = new Date(entry.created_at).toLocaleString();
 
-        if (this.sessions.length === 0) {
-            container.innerHTML = '<div style="color: var(--text-secondary); font-style: italic;">No chat sessions found</div>';
+        content.innerHTML = `
+            <div class="emr-detail-section">
+                <h4>Basic Information</h4>
+                <p><strong>Date:</strong> ${date}</p>
+                <p><strong>Confidence:</strong> ${Math.round(entry.confidence_score * 100)}%</p>
+                <p><strong>Original Message:</strong></p>
+                <div style="background-color: var(--bg-secondary); padding: var(--spacing-md); border-radius: 8px; margin-top: var(--spacing-sm);">
+                    ${entry.original_message}
+                </div>
+            </div>
+
+            ${entry.extracted_data.diagnosis?.length > 0 ? `
+                <div class="emr-detail-section">
+                    <h4>Diagnoses</h4>
+                    <ul class="emr-detail-list">
+                        ${entry.extracted_data.diagnosis.map(d => `<li>${d}</li>`).join('')}
+                    </ul>
+                </div>
+            ` : ''}
+
+            ${entry.extracted_data.symptoms?.length > 0 ? `
+                <div class="emr-detail-section">
+                    <h4>Symptoms</h4>
+                    <ul class="emr-detail-list">
+                        ${entry.extracted_data.symptoms.map(s => `<li>${s}</li>`).join('')}
+                    </ul>
+                </div>
+            ` : ''}
+
+            ${entry.extracted_data.medications?.length > 0 ? `
+                <div class="emr-detail-section">
+                    <h4>Medications</h4>
+                    ${entry.extracted_data.medications.map(med => `
+                        <div class="medication-item">
+                            <div class="medication-name">${med.name}</div>
+                            <div class="medication-details">
+                                ${med.dosage ? `Dosage: ${med.dosage}` : ''}
+                                ${med.frequency ? ` | Frequency: ${med.frequency}` : ''}
+                                ${med.duration ? ` | Duration: ${med.duration}` : ''}
+                            </div>
+                        </div>
+                    `).join('')}
+                </div>
+            ` : ''}
+
+            ${entry.extracted_data.vital_signs && Object.values(entry.extracted_data.vital_signs).some(v => v) ? `
+                <div class="emr-detail-section">
+                    <h4>Vital Signs</h4>
+                    <div class="vital-signs-grid">
+                        ${Object.entries(entry.extracted_data.vital_signs).map(([key, value]) =>
+                            value ? `
+                                <div class="vital-sign-item">
+                                    <div class="vital-sign-label">${key.replace('_', ' ').toUpperCase()}</div>
+                                    <div class="vital-sign-value">${value}</div>
+                                </div>
+                            ` : ''
+                        ).join('')}
+                    </div>
+                </div>
+            ` : ''}
+
+            ${entry.extracted_data.lab_results?.length > 0 ? `
+                <div class="emr-detail-section">
+                    <h4>Lab Results</h4>
+                    <ul class="emr-detail-list">
+                        ${entry.extracted_data.lab_results.map(lab => `
+                            <li>
+                                <strong>${lab.test_name}:</strong> ${lab.value} ${lab.unit || ''}
+                                ${lab.reference_range ? ` (Normal: ${lab.reference_range})` : ''}
+                            </li>
+                        `).join('')}
+                    </ul>
+                </div>
+            ` : ''}
+
+            ${entry.extracted_data.procedures?.length > 0 ? `
+                <div class="emr-detail-section">
+                    <h4>Procedures</h4>
+                    <ul class="emr-detail-list">
+                        ${entry.extracted_data.procedures.map(p => `<li>${p}</li>`).join('')}
+                    </ul>
+                </div>
+            ` : ''}
+
+            ${entry.extracted_data.notes ? `
+                <div class="emr-detail-section">
+                    <h4>Notes</h4>
+                    <p>${entry.extracted_data.notes}</p>
+                </div>
+            ` : ''}
+        `;
+
+        modal.classList.add('show');
+    }
+
+    async deleteEMREntry(emrId) {
+        if (!confirm('Are you sure you want to delete this EMR entry?')) {
             return;
         }
 
-        container.innerHTML = '';
+        try {
+            const response = await fetch(`/emr/${emrId}`, {
+                method: 'DELETE'
+            });
 
-        this.sessions.forEach(session => {
-            const sessionEl = document.createElement('div');
-            sessionEl.className = 'session-item';
-            sessionEl.innerHTML = `
-                <div class="session-title">${session.title || 'Untitled Session'}</div>
-                <div class="session-meta">
-                    <span class="session-date">${this.formatDate(session.created_at)}</span>
-                    <span class="session-messages">${session.message_count || 0} messages</span>
-                </div>
-            `;
+            if (response.ok) {
+                this.loadEMRData(); // Refresh the data
+                this.loadPatientStats(); // Refresh stats
+            } else {
+                alert('Failed to delete EMR entry');
+            }
+        } catch (error) {
+            console.error('Error deleting EMR entry:', error);
+            alert('Error deleting EMR entry');
+        }
+    }
 
-            sessionEl.addEventListener('click', () => {
-                // Could open session details or redirect to main page with session
-                window.location.href = `/?session_id=${session.session_id}`;
+    filterEntries(query) {
+        if (!query.trim()) {
+            this.filteredEntries = [...this.emrEntries];
+        } else {
+            this.filteredEntries = this.emrEntries.filter(entry => {
+                const searchText = query.toLowerCase();
+                return (
+                    entry.original_message.toLowerCase().includes(searchText) ||
+                    entry.extracted_data.diagnosis?.some(d => d.toLowerCase().includes(searchText)) ||
+                    entry.extracted_data.symptoms?.some(s => s.toLowerCase().includes(searchText)) ||
+                    entry.extracted_data.medications?.some(m => m.name.toLowerCase().includes(searchText)) ||
+                    entry.extracted_data.notes?.toLowerCase().includes(searchText)
+                );
             });
+        }
+        this.renderEMRTable();
+    }
+
+    applyFilters() {
+        const dateFilter = document.getElementById('dateFilter').value;
+        const typeFilter = document.getElementById('typeFilter').value;
+
+        this.filteredEntries = this.emrEntries.filter(entry => {
+            // Date filter
+            if (dateFilter !== 'all') {
+                const entryDate = new Date(entry.created_at);
+                const now = new Date();
+
+                switch (dateFilter) {
+                    case 'today':
+                        if (entryDate.toDateString() !== now.toDateString()) return false;
+                        break;
+                    case 'week':
+                        const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+                        if (entryDate < weekAgo) return false;
+                        break;
+                    case 'month':
+                        const monthAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+                        if (entryDate < monthAgo) return false;
+                        break;
+                }
+            }
+
+            // Type filter
+            if (typeFilter !== 'all') {
+                const entryType = this.getEMRType(entry.extracted_data);
+                if (entryType !== typeFilter) return false;
+            }
 
-            container.appendChild(sessionEl);
+            return true;
         });
+
+        this.renderEMRTable();
+    }
+
+    openSearchModal() {
+        document.getElementById('searchModal').classList.add('show');
     }
 
-    async savePatientData() {
+    async performAdvancedSearch() {
+        const semanticQuery = document.getElementById('semanticSearchInput').value.trim();
+        const exactQuery = document.getElementById('exactSearchInput').value.trim();
+
+        if (!semanticQuery && !exactQuery) {
+            alert('Please enter a search query');
+            return;
+        }
+
         this.showLoading(true);
 
         try {
-            const updateData = {
-                name: document.getElementById('patientNameInput').value.trim(),
-                age: parseInt(document.getElementById('patientAgeInput').value) || null,
-                sex: document.getElementById('patientSexInput').value || null,
-                ethnicity: document.getElementById('patientEthnicityInput').value || null,
-                phone: document.getElementById('patientPhoneInput').value.trim() || null,
-                email: document.getElementById('patientEmailInput').value.trim() || null,
-                address: document.getElementById('patientAddressInput').value.trim() || null,
-                medications: this.medications,
-                past_assessment_summary: document.getElementById('pastAssessmentInput').value.trim() || null
-            };
-
-            const resp = await fetch(`/patient/${this.patientId}`, {
-                method: 'PATCH',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(updateData)
-            });
+            let searchResults = [];
+
+            if (semanticQuery) {
+                const response = await fetch(`/emr/search/${this.currentPatientId}?query=${encodeURIComponent(semanticQuery)}&limit=50`);
+                if (response.ok) {
+                    searchResults = await response.json();
+                }
+            }
 
-            if (resp.ok) {
-                this.showSuccess('Patient data saved successfully!');
-                // Update the header with new name
-                document.getElementById('patientName').textContent = updateData.name || 'Unknown';
+            if (exactQuery) {
+                const exactResults = this.emrEntries.filter(entry => {
+                    const searchText = exactQuery.toLowerCase();
+                    return (
+                        entry.original_message.toLowerCase().includes(searchText) ||
+                        entry.extracted_data.diagnosis?.some(d => d.toLowerCase().includes(searchText)) ||
+                        entry.extracted_data.symptoms?.some(s => s.toLowerCase().includes(searchText)) ||
+                        entry.extracted_data.medications?.some(m => m.name.toLowerCase().includes(searchText)) ||
+                        entry.extracted_data.notes?.toLowerCase().includes(searchText)
+                    );
+                });
+
+                // Merge results if both searches were performed
+                if (semanticQuery) {
+                    const exactIds = new Set(exactResults.map(r => r.emr_id));
+                    searchResults = searchResults.concat(exactResults.filter(r => !exactIds.has(r.emr_id)));
             } else {
-                throw new Error('Failed to save patient data');
+                    searchResults = exactResults;
+                }
             }
+
+            this.filteredEntries = searchResults;
+            this.renderEMRTable();
+
         } catch (error) {
-            console.error('Error saving patient data:', error);
-            this.showError('Failed to save patient data. Please try again.');
+            console.error('Error performing search:', error);
+            alert('Error performing search');
         } finally {
             this.showLoading(false);
         }
     }
 
-    exportPatientData() {
-        if (!this.patientData) {
-            this.showError('No patient data to export');
-            return;
+    showLoading(show) {
+        const loadingState = document.getElementById('loadingState');
+        const tableContainer = document.querySelector('.emr-table-container');
+
+        if (show) {
+            loadingState.style.display = 'block';
+            tableContainer.style.display = 'none';
+        } else {
+            loadingState.style.display = 'none';
+            tableContainer.style.display = 'block';
         }
-
-        const exportData = {
-            _id: this.patientData._id,
-            name: this.patientData.name,
-            age: this.patientData.age,
-            sex: this.patientData.sex,
-            ethnicity: this.patientData.ethnicity,
-            phone: this.patientData.phone,
-            email: this.patientData.email,
-            address: this.patientData.address,
-            medications: this.medications,
-            past_assessment_summary: this.patientData.past_assessment_summary,
-            created_at: this.patientData.created_at,
-            updated_at: this.patientData.updated_at,
-            sessions: this.sessions
-        };
-
-        const blob = new Blob([JSON.stringify(exportData, null, 2)], { type: 'application/json' });
-        const url = URL.createObjectURL(blob);
-        const a = document.createElement('a');
-        a.href = url;
-        a.download = `patient-${this.patientData._id}-emr.json`;
-        document.body.appendChild(a);
-        a.click();
-        document.body.removeChild(a);
-        URL.revokeObjectURL(url);
     }
 
-    formatDate(dateString) {
-        if (!dateString) return 'Unknown date';
-        const date = new Date(dateString);
-        return date.toLocaleDateString() + ' ' + date.toLocaleTimeString();
-    }
+    showEmptyState() {
+        const emptyState = document.getElementById('emptyState');
+        const tableContainer = document.querySelector('.emr-table-container');
 
-    showLoading(show) {
-        const overlay = document.getElementById('loadingOverlay');
-        if (overlay) {
-            overlay.style.display = show ? 'flex' : 'none';
-        }
+        emptyState.style.display = 'block';
+        tableContainer.style.display = 'none';
     }
 
-    showError(message) {
-        alert('Error: ' + message);
-    }
+    showErrorState(message) {
+        const emptyState = document.getElementById('emptyState');
+        const tableContainer = document.querySelector('.emr-table-container');
+
+        // Update the empty state to show error message
+        emptyState.querySelector('h3').textContent = 'Error Loading EMR Data';
+        emptyState.querySelector('p').textContent = message;
+        emptyState.querySelector('.btn').style.display = 'none';
 
-    showSuccess(message) {
-        alert('Success: ' + message);
+        emptyState.style.display = 'block';
+        tableContainer.style.display = 'none';
     }
 }
 
-// Initialize EMR when DOM is loaded
+// Initialize the EMR page when DOM is loaded
 document.addEventListener('DOMContentLoaded', () => {
-    new PatientEMR();
+    window.emrPage = new EMRPage();
 });