Merge branch 'hf_main' into hf_mongo

README.md

@@ -13,310 +13,172 @@ app_port: 7860
 
 # Medical AI Assistant
 
-A sophisticated AI-powered medical chatbot system with ChatGPT-like UI, multi-user support, session management, and medical context awareness.
+AI-powered medical chatbot with patient-centric memory, MongoDB persistence, and a fast, modern UI.
 
-## 🚀 Features
+## 🚀 Key Features
 
-### Core Functionality
-- **AI-Powered Medical Chat**: Intelligent responses to medical questions using advanced language models
-- **Multi-User Support**: Individual user profiles with role-based customization (Physician, Nurse, Medical Student, etc.)
-- **Chat Session Management**: Multiple concurrent chat sessions per user with persistent history
-- **Medical Context Memory**: LRU-based memory system that maintains conversation context and medical history
-- **API Key Rotation**: Dynamic rotation of Gemini API keys for reliability and rate limit management
+- Patient-centric RAG memory
+  - Short-term: last 3 QA summaries in in-memory LRU (fast context)
+  - Long-term: last 20 QA summaries per patient persisted in MongoDB (continuity)
+- Chat history persistence per session in MongoDB
+- Patient/Doctor context saved on all messages and summaries
+- Patient search typeahead (name or ID) with instant session hydration
+- Doctor dropdown with built‑in "Create doctor user..." flow
+- Modern UI: sidebar sessions, modals (doctor, settings, patient profile), dark/light mode, mobile-friendly
+- Model integration: Gemini responses, NVIDIA summariser fallback via key rotators
 
-### User Interface
-- **ChatGPT-like Design**: Familiar, intuitive interface optimized for medical professionals
-- **Responsive Design**: Works seamlessly on desktop, tablet, and mobile devices
-- **Dark/Light Theme**: Automatic theme switching with system preference detection
-- **Real-time Chat**: Smooth, responsive chat experience with typing indicators
-- **Session Management**: Easy navigation between different chat sessions
+## 🏗️ Architecture (high-level)
 
 ### Medical Features
-- **Medical Knowledge Base**: Built-in medical information for common symptoms, conditions, and medications
-- **Context Awareness**: Remembers previous conversations and provides relevant medical context
+- **Medical Knowledge Base**: Built-in medical information for common symptoms, 
+conditions, and medications
+- **Context Awareness**: Remembers previous conversations and provides relevant medical 
+context
 - **Role-Based Responses**: Tailored responses based on user's medical role and specialty
 - **Medical Disclaimers**: Appropriate warnings and disclaimers for medical information
-- **Export Functionality**: Export chat sessions for medical records or educational purposes
-
-## 🏗️ Architecture
-
-### Core Components
-```
-MedicalDiagnosisSystem/
-├── app.py                 # FastAPI main application
-├── memo/
-│   ├── memory.py         # Enhanced LRU memory system
-│   └── history.py        # Medical history manager
-├── utils/
-│   ├── rotator.py        # API key rotation system
-│   ├── embeddings.py     # Embedding client with fallback
-│   └── logger.py         # Structured logging
-└── static/
-    ├── index.html        # Main UI
-    ├── styles.css        # Styling
-    └── app.js           # Frontend logic
-```
-
-### Memory System
-- **User Profiles**: Persistent user data with preferences and roles
-- **Chat Sessions**: Individual conversation threads with message history
-- **Medical Context**: QA summaries stored in LRU cache for quick retrieval
-- **Semantic Search**: Embedding-based similarity search for relevant medical information
-
-### API Integration
-- **Gemini API**: Google's advanced language model for medical responses
-- **Key Rotation**: Automatic rotation on rate limits or errors
-- **Fallback Support**: Graceful degradation when external APIs are unavailable
-
-## 🛠️ Installation
+- **Export Functionality**: Export chat sessions for medical records or educational 
+purposes
+
+Backend (FastAPI):
+- `src/core/memory/memory.py`: LRU short‑term memory + sessions
+- `src/core/memory/history.py`: builds context; writes memory/messages to Mongo
+- `src/data/`: Mongo helpers (modularized)
+  - `connection.py`: Mongo connection + collection names
+  - `session/operations.py`: chat sessions (ensure/list/delete/etc.)
+  - `message/operations.py`: chat messages (save/list)
+  - `patient/operations.py`: patients (get/create/update/search)
+  - `user/operations.py`: accounts/doctors (create/search/list)
+  - `medical/operations.py`: medical records + memory summaries
+  - `utils.py`: generic helpers (indexing, backups)
+- `src/api/routes/`: `chat`, `session`, `user` (patients), `system`, `static`
+
+Frontend (static):
+- `static/index.html`, `static/css/styles.css`
+- `static/js/app.js` (or modularized under `static/js/ui/*` and `static/js/chat/*` — see `UI_SETUP.md`)
+
+## 🛠️ Quick Start
 
 ### Prerequisites
-- Python 3.8+
-- pip package manager
-- Modern web browser
+- Python 3.11+
+- pip
 
 ### Setup
-1. **Clone the repository**
-   ```bash
-   git clone <repository-url>
-   cd MedicalDiagnosisSystem
-   ```
-
-2. **Install dependencies**
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-3. **Set environment variables**
-   ```bash
-   # Create .env file
-   echo "GEMINI_API_1=your_gemini_api_key_1" > .env
-   echo "GEMINI_API_2=your_gemini_api_key_2" >> .env
-   echo "GEMINI_API_3=your_gemini_api_key_3" >> .env
-   ```
-
-4. **Run the application**
-   ```bash
-   python app.py
-   ```
-
-5. **Access the UI**
-   Open your browser and navigate to `http://localhost:8000`
-
-## 🔧 Configuration
-
-### Environment Variables
-- `GEMINI_API_1` through `GEMINI_API_5`: Gemini API keys for rotation
-- `LOG_LEVEL`: Logging level (DEBUG, INFO, WARNING, ERROR)
-- `PORT`: Server port (default: 8000)
-
-### Memory Settings
-- **LRU Capacity**: Default 50 QA summaries per user
-- **Max Sessions**: Default 20 sessions per user
-- **Session Timeout**: Configurable session expiration
+1. Clone and install
+```bash
+git clone https://huggingface.co/spaces/MedAI-COS30018/MedicalDiagnosisSystem
+cd MedAI
+pip install -r requirements.txt
+```
+2. Configure environment
+```bash
+# Create .env
+echo "GEMINI_API_1=your_gemini_api_key_1" > .env
+echo "NVIDIA_API_1=your_nvidia_api_key_1" >> .env
+# MongoDB (required)
+echo "MONGO_USER=your_mongodb_connection_string" >> .env
+# Optional DB name (default: medicaldiagnosissystem)
+# Optional DB name (default: medicaldiagnosissystem). Env var key: USER_DB
+echo "USER_DB=medicaldiagnosissystem" >> .env
+```
+3. Run
+```bash
+python -m src.main
+```
+Helpful: [UI SETUP](https://huggingface.co/spaces/MedAI-COS30018/MedicalDiagnosisSystem/blob/main/UI_SETUP.md) | [SETUP GUIDE](https://huggingface.co/spaces/MedAI-COS30018/MedicalDiagnosisSystem/blob/main/SETUP_GUIDE.md)
 
-### Embedding Model
-- **Default Model**: `all-MiniLM-L6-v2` (384 dimensions)
-- **Fallback Mode**: Hash-based embeddings when model unavailable
-- **GPU Support**: Optional CUDA acceleration for embeddings
+## 🔧 Config
+- `GEMINI_API_1..5`, `NVIDIA_API_1..5`
+- `MONGO_USER`, `MONGO_DB`
+- `LOG_LEVEL`, `PORT`
+- Memory: 3 short‑term, 20 long‑term
 
 ## 📱 Usage
-
-### Getting Started
-1. **Access the Application**: Navigate to the provided URL
-2. **Create User Profile**: Click on your profile to set name, role, and specialty
-3. **Start New Chat**: Click "New Chat" to begin a conversation
-4. **Ask Medical Questions**: Type your medical queries in natural language
-5. **Manage Sessions**: Use the sidebar to switch between different chat sessions
-
-### User Roles
-- **Physician**: Full medical context with clinical guidance
-- **Nurse**: Nursing-focused responses and care instructions
-- **Medical Student**: Educational content with learning objectives
-- **Healthcare Professional**: General medical information
-- **Patient**: Educational content with appropriate disclaimers
-
-### Features
-- **Real-time Chat**: Instant responses with typing indicators
-- **Session Export**: Download chat history as JSON files
-- **Context Memory**: System remembers previous conversations
-- **Medical Disclaimers**: Appropriate warnings for medical information
-- **Responsive Design**: Works on all device sizes
-
-## 🔒 Security & Privacy
-
-### Data Protection
-- **Local Storage**: User data stored locally in browser (no server persistence)
-- **Session Isolation**: Users can only access their own data
-- **No PII Storage**: Personal information not logged or stored
-- **Medical Disclaimers**: Clear warnings about information limitations
-
-### API Security
-- **Key Rotation**: Automatic API key rotation for security
-- **Rate Limiting**: Built-in protection against API abuse
-- **Error Handling**: Graceful degradation on API failures
-
-## 🧪 Development
-
-### Local Development
+1. Select/create a doctor; set role/specialty.
+2. Search patient by name/ID; select a result.
+3. Start a new chat; ask your question.
+4. Manage sessions in the sidebar (rename/delete from menu).
+5. View patient profile and create/edit via modals/pages.
+
+## 🔌 Endpoints (selected)
+- `POST /chat` → `{ response, session_id, timestamp, medical_context? }`
+- `POST /sessions` → `{ session_id }`
+- `GET /patients/{patient_id}/sessions`
+- `GET /sessions/{session_id}/messages`
+- `DELETE /sessions/{session_id}` → deletes session (cache + Mongo) and its messages
+- `GET /patients/search?q=term&limit=8`
+
+## 🔒 Data & Privacy
+- MongoDB persistence keyed by `patient_id` with `doctor_id` attribution
+- UI localStorage for UX (doctor list, preferences, selected patient)
+- Avoid logging PHI; secure Mongo credentials
+
+## 🧪 Dev
 ```bash
-# Install development dependencies
 pip install -r requirements.txt
-
-# Run with auto-reload
-python app.py
-
-# Run tests
-pytest
-
-# Format code
-black .
-
-# Lint code
-flake8
+python -m src.main   # run
+pytest               # tests
+black . && flake8    # format + lint
 ```
 
 ### Project Structure
 ```
-medical_diagnosis_system/
-├── scripts/
-│   └── download_model.py        # Model downloading script
+MedAI/
 ├── src/
 │   ├── api/
-│   │   └── routes/              # API endpoint handlers
-│   │       ├── chat.py
-│   │       ├── session.py
-│   │       ├── static.py
-│   │       ├── system.py
-│   │       └── user.py
+│   │   └── routes/
+│   │       ├── chat.py          # Chat endpoint
+│   │       ├── session.py       # Session endpoints
+│   │       ├── user.py          # Patient APIs (get/create/update/search)
+│   │       ├── system.py        # Health/info
+│   │       └── static.py        # Serve index
 │   ├── core/
-│   │   ├── memory/              # Memory management
-│   │   │   ├── memory.py
-│   │   │   └── history.py
-│   │   └── state.py             # Application state management
-│   ├── domain/
-│   │   └── knowledge/           # Domain-specific knowledge
-│   │       └── medical_kb.py
-│   ├── models/                  # Data models
+│   │   ├── memory/
+│   │   │   ├── memory.py        # LRU short‑term memory + sessions
+│   │   │   └── history.py       # Context builder, persistence hooks
+│   │   └── state.py             # App state (rotators, embeddings, memory)
+│   ├── data/
+│   │   ├── __init__.py          # Barrel exports for data layer
+│   │   ├── connection.py        # Mongo connection + collection names
+│   │   ├── utils.py             # Indexing, backups
+│   │   ├── session/
+│   │   │   └── operations.py    # Sessions: ensure/list/delete
+│   │   ├── message/
+│   │   │   └── operations.py    # Messages: save/list
+│   │   ├── patient/
+│   │   │   └── operations.py    # Patients: get/create/update/search
+│   │   ├── user/
+│   │   │   └── operations.py    # Accounts/Doctors
+│   │   └── medical/
+│   │       └── operations.py    # Medical records + memory summaries
+│   ├── models/
 │   │   ├── chat.py
 │   │   └── user.py
-│   ├── services/                # Business logic services
-│   │   ├── medical_response.py
-│   │   └── summariser.py
-│   ├── utils/                   # Utility functions
-│   │   ├── __init__.py
+│   ├── services/
+│   │   ├── medical_response.py  # Calls model(s)
+│   │   └── summariser.py        # Title/QA summarisation
+│   ├── utils/
 │   │   ├── embeddings.py
 │   │   ├── logger.py
-│   │   ├── naming.py
 │   │   └── rotator.py
-│   └ main.py                    # Application entry point
-├── static/                      # Frontend assets
-│   ├── js/
-│   │   ├── app.js
-│   │   └── health.js
+│   └── main.py                  # FastAPI entrypoint
+├── static/
+│   ├── index.html
 │   ├── css/
-│   │   └── styles.css
-│   ├── health.html
-│   ├── icon.svg
-│   └── index.html
-├── .dockerignore
-├── .gitattributes
-├── .gitignore
-├── docker-compose.yml
+│   │   ├── styles.css
+│   │   └── patient.css
+│   ├── js/
+│   │   ├── app.js               # Submodules under /ui/* and /chat/*
+│   │   └── patient.js
+│   └── patient.html
+├── requirements.txt
+├── requirements-dev.txt
 ├── Dockerfile
-├── LICENSE                     # Project license
-├── README.md                   # Project documentation
-├── requirements.txt            # Production dependencies
-├── requirements-dev.txt        # Development dependencies
-├── SETUP_GUIDE.md              # Detailed setup instructions
-└── start.py                    # Application launcher
-```
-
-### Adding New Features
-1. **Backend**: Add new endpoints in `app.py`
-2. **Memory**: Extend memory system in `memo/memory.py`
-3. **Frontend**: Update UI components in `static/` files
-4. **Testing**: Add tests for new functionality
-
-## 🚀 Deployment
-
-### Production Considerations
-- **Environment Variables**: Secure API key management
-- **HTTPS**: Enable SSL/TLS for production
-- **Rate Limiting**: Implement request rate limiting
-- **Monitoring**: Add health checks and logging
-- **Database**: Consider persistent storage for production
-
-### Docker Deployment
-```dockerfile
-FROM python:3.9-slim
-WORKDIR /app
-COPY requirements.txt .
-RUN pip install -r requirements.txt
-COPY . .
-EXPOSE 8000
-CMD ["python", "app.py"]
+├── docker-compose.yml
+├── LICENSE
+└── README.md
 ```
 
-### Cloud Deployment
-- **AWS**: Deploy on EC2 or Lambda
-- **Google Cloud**: Use Cloud Run or App Engine
-- **Azure**: Deploy on App Service
-- **Heroku**: Simple deployment with Procfile
-
-## 📊 Performance
-
-### Optimization Features
-- **Lazy Loading**: Embedding models loaded on demand
-- **LRU Caching**: Efficient memory management
-- **API Rotation**: Load balancing across multiple API keys
-- **Fallback Modes**: Graceful degradation on failures
-
-### Monitoring
-- **Health Checks**: `/health` endpoint for system status
-- **Resource Usage**: CPU and memory monitoring
-- **API Metrics**: Response times and success rates
-- **Error Tracking**: Comprehensive error logging
-
-## 🤝 Contributing
-
-### Development Guidelines
-1. **Code Style**: Follow PEP 8 and use Black formatter
-2. **Testing**: Add tests for new features
-3. **Documentation**: Update README and docstrings
-4. **Security**: Follow security best practices
-5. **Performance**: Consider performance implications
-
-### Pull Request Process
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests and documentation
-5. Submit a pull request
-
-## 📄 License
-
-This project is licensed under the MIT License - see the LICENSE file for details.
-
-## ⚠️ Disclaimer
-
-**Medical Information Disclaimer**: This application provides educational medical information only. It is not a substitute for professional medical advice, diagnosis, or treatment. Always consult with qualified healthcare professionals for medical decisions.
-
-**AI Limitations**: While this system uses advanced AI technology, it has limitations and should not be relied upon for critical medical decisions.
-
-## 🆘 Support
-
-### Getting Help
-- **Issues**: Report bugs via GitHub Issues
-- **Documentation**: Check this README and code comments
-- **Community**: Join discussions in GitHub Discussions
-
-### Common Issues
-- **API Keys**: Ensure Gemini API keys are properly set
-- **Dependencies**: Verify all requirements are installed
-- **Port Conflicts**: Check if port 8000 is available
-- **Memory Issues**: Monitor system resources
-
----
-
-**Built with ❤️ for the medical community**
+## 🧾 License & Disclaimer
+- MIT License (see [LICENSE](https://huggingface.co/spaces/MedAI-COS30018/MedicalDiagnosisSystem/blob/main/LICENSE))
+- Educational information only; not a substitute for professional medical advice
+- Team D1 - COS30018, Swinburne University of Technology

TODO.md

@@ -6,6 +6,7 @@
 - [ ] Accounts
 - [ ] Saving chats
 - [ ] MongoDB hosting
+
 ## Suggestions
 
 1. Dependency Injection: — Investigated
@@ -47,3 +48,22 @@
 10. State Management:
 - Global state in MedicalState could be improved
 - Session management could be more robust
+
+## PHASE 2:
+- [ ] EMR enhancement
+- [ ] Naive RAG integration
+- [ ] Chat history consistency
+- [ ] Summary history to EMR
+
+## PHASE 3:
+- [ ] Multimodal integration
+- [ ] Reasoning orchestrator
+- [ ] Dynamic/Tree/Graph RAG
+- [ ] Integrate specialist model
+
+## PHASE 4:
+- [ ] Multimodal validation
+- [ ] Orchestrator validation
+- [ ] RAG validation
+- [ ] UI Enhancement
+- [ ] Future suggestions

UI_SETUP.md

@@ -0,0 +1,147 @@
+## UI setup and structure
+
+This document explains the browser UI code structure, responsibilities of each module, how the app boots, what localStorage keys are used, and how the UI communicates with the Python backend.
+
+### 1) Directory layout (frontend)
+
+```
+static/
+  index.html                # Main UI page
+  css/
+    styles.css             # Global theme + layout
+    patient.css            # Patient registration page
+  js/
+    app.js                 # Legacy monolith boot (kept for compatibility)
+    core.js                # (optional) Core app bootstrap if using modules
+    boot.js                # (optional) Bootstrapping helpers for modules
+    ui/                    # UI-layer modules (DOM + events)
+      sidebar.js           # Sidebar open/close, overlay, sessions list
+      modals.js            # User/doctor modal, settings modal, edit-title modal
+      patient.js           # Patient section: typeahead, status, select
+      theme.js             # Theme/font-size handling
+      voice.js             # Web Speech API setup (optional)
+      utils.js             # Small DOM utilities (qs, on, etc.)
+    chat/                  # Chat logic modules
+      messages.js          # Render and manage messages in chat pane
+      sessions.js          # Client-side session CRUD (local + fetch from backend)
+      api.js               # Fetch helpers to talk to backend endpoints
+      state.js             # Ephemeral UI state (current user/patient/session)
+
+patient.html                # Patient registration page
+```
+
+Notes:
+- If `core.js` and `boot.js` are present and loaded as type="module", they should import from `js/ui/*` and `js/chat/*`. If you continue using `app.js`, it should delegate to these modules (or keep the current inline logic).
+
+### 2) Boot sequence
+
+Minimal boot (non-module):
+- `index.html` loads `app.js` (non-module). `app.js` wires events, restores local state, applies theme, renders sidebar sessions, and binds modals.
+
+Module-based boot (recommended):
+- `index.html` includes:
+  - `<script type="module" src="/static/js/core.js"></script>`
+  - `core.js` imports from `ui/*` and `chat/*`, builds the app, and calls `boot.init()`.
+  - `boot.js` provides `init()` that wires all UI modules in a deterministic order.
+
+Expected init order:
+1. Load preferences (theme, font size) and apply to `document.documentElement`.
+2. Restore user (doctor) profile from localStorage.
+3. Restore selected patient id from localStorage and, if present, preload sessions from backend.
+4. Wire global UI events: sidebar toggle, outside-click overlay, send, clear, export.
+5. Wire modals: user/doctor modal, settings modal, edit-session-title modal.
+6. Wire patient section: typeahead search + selection + status.
+7. Render current session messages.
+
+### 3) State model (in-memory)
+
+- `state.user`: current doctor `{ id, name, role, specialty, createdAt }`.
+- `state.patientId`: 8-digit patient id string kept in localStorage under `medicalChatbotPatientId`.
+- `state.currentSession`: `{ id, title, messages[], createdAt, lastActivity, source }`.
+- `state.sessions`: local session cache (for non-backend sessions).
+
+LocalStorage keys:
+- `medicalChatbotUser`: current doctor object.
+- `medicalChatbotDoctors`: array of `{ name }` (unique, used for the dropdown).
+- `medicalChatbotPatientId`: selected patient id.
+- `medicalChatbotPreferences`: `{ theme, fontSize, autoSave, notifications }`.
+
+### 4) Components and responsibilities
+
+UI modules (ui/*):
+- `sidebar.js`: opens/closes sidebar, manages `#sidebarOverlay`, renders session cards, handles outside-click close.
+- `modals.js`: shows/hides user/doctor modal, settings modal, edit-title modal. Populates doctor dropdown with a first item "Create doctor user..." and injects current doctor name if missing.
+- `patient.js`: typeahead over `/patients/search?q=...`, renders suggestions, sets `state.patientId` and persists to localStorage, triggers sessions preload.
+- `theme.js`: reads/writes `medicalChatbotPreferences`, applies `data-theme` on `<html>`, sets root font-size.
+- `voice.js`: optional Web Speech API wiring to fill `#chatInput`.
+
+Chat modules (chat/*):
+- `messages.js`: adds user/assistant messages, formats content, timestamps, scrolls to bottom.
+- `sessions.js`: saves/loads local sessions, hydrates backend sessions (`GET /sessions/{id}/messages`), deletes/renames sessions.
+- `api.js`: wrappers around backend endpoints (`/chat`, `/patients/*`, `/sessions/*`). Adds `Accept: application/json` and logs responses.
+- `state.js`: exports a singleton state object used by UI and chat modules.
+
+### 5) Backend endpoints used by the UI
+
+- `POST /chat` — main inference call.
+- `GET /patients/search?q=...&limit=...` — typeahead. Returns `{ results: [{ name, patient_id, ...}, ...] }`.
+- `GET /patients/{patient_id}` — patient profile (used by patient modal).
+- `POST /patients` — create patient (used by patient.html). Returns `{ patient_id, name, ... }`.
+- `PATCH /patients/{patient_id}` — update patient fields.
+- `GET /patients/{patient_id}/sessions` — list sessions.
+- `GET /sessions/{session_id}/messages?limit=...` — hydrate messages.
+
+### 6) Theming
+
+- CSS variables are declared under `:root` and overridden under `[data-theme="dark"]`.
+- On boot, the app reads `medicalChatbotPreferences.theme` and applies:
+  - `auto` => matches `prefers-color-scheme`.
+  - `light`/`dark` => sets `document.documentElement.dataset.theme` accordingly.
+
+### 7) Patient typeahead contract
+
+- Input: `#patientIdInput`.
+- Suggestions container: `#patientSuggestions` (absolute, below input).
+- Debounce: ~200 ms. Request: `GET /patients/search?q=<term>&limit=8`.
+- On selection: set `state.patientId`, persist to localStorage, update `#patientStatus`, call sessions preload, close suggestions.
+- On Enter:
+  - If exact 8 digits, call `loadPatient()`.
+  - Otherwise, search and pick the first match if any.
+
+### 8) Sidebar behavior
+
+- Open: click `#sidebarToggle`.
+- Close: clicking outside (main area) or on `#sidebarOverlay` hides the sidebar on all viewports.
+
+### 9) Doctor dropdown rules
+
+- First option is always "Create doctor user..." (value: `__create__`).
+- If the current doctor name is not in `medicalChatbotDoctors`, it is inserted and saved.
+- Choosing the create option reveals an inline mini-form to add a new doctor; Confirm inserts and selects it.
+
+### 10) Voice input (optional)
+
+- If using `voice.js`: checks `window.SpeechRecognition || window.webkitSpeechRecognition`.
+- Streams interim results into `#chatInput`, toggled by `#microphoneBtn`.
+
+### 11) Patient registration flow
+
+- `patient.html` posts to `POST /patients` with name/age/sex/etc.
+- On success, shows a modal with the new Patient ID and two actions: Return to main page, Edit patient profile.
+- Stores `medicalChatbotPatientId` and redirects when appropriate.
+
+### 12) Troubleshooting
+
+- Sidebar won’t close: ensure `#sidebarOverlay` exists and that `sidebar.js`/`app.js` wires outside-click and overlay click listeners.
+- Doctor dropdown empty: confirm `medicalChatbotDoctors` exists or `populateDoctorSelect()` runs on opening the modal.
+- Typeahead doesn’t show results: open network tab and hit `/patients/search?q=test`; ensure 200 and JSON. Logs are printed by FastAPI (see server console).
+- Theme not changing: ensure `theme.js` sets `data-theme` on `<html>` and `styles.css` uses `[data-theme="dark"]` overrides.
+
+### 13) Migration from app.js to modules
+
+If you refactored into `ui/*` and `chat/*`:
+1. Ensure `index.html` loads `core.js` as a module.
+2. In `core.js`, import and initialize modules in the order described in Boot sequence.
+3. Keep `app.js` only if you need compatibility; progressively move code into the relevant module files.
+
+

src/api/routes/chat.py

@@ -11,6 +11,8 @@ from src.services.medical_response import generate_medical_response
 from src.services.summariser import summarise_title_with_nvidia
 from src.utils.logger import logger
 
+from src.data import ensure_session
+
 router = APIRouter()
 
 @router.post("/chat", response_model=ChatResponse)
@@ -18,14 +20,16 @@ async def chat_endpoint(
 	request: ChatRequest,
 	state: MedicalState = Depends(get_state)
 ):
-	"""Handle chat messages and generate medical responses"""
+	"""
+	Process a chat message, generate response, and persist short-term cache + long-term Mongo.
+	"""
 	start_time = time.time()
 
 	try:
-		logger().info(f"Chat request from user {request.user_id} in session {request.session_id}")
+		logger().info(f"POST /chat user={request.user_id} session={request.session_id} patient={request.patient_id} doctor={request.doctor_id}")
 		logger().info(f"Message: {request.message[:100]}...")  # Log first 100 chars of message
 
-		# Get or create user profile
+		# Get or create user profile (doctor as current user profile)
 		user_profile = state.memory_system.get_user(request.user_id)
 		if not user_profile:
 			state.memory_system.create_user(request.user_id, request.user_role or "Anonymous")
@@ -35,7 +39,7 @@ async def chat_endpoint(
 					{"specialty": request.user_specialty}
 				)
 
-		# Get or create session
+		# Get or create session (cache)
 		session = state.memory_system.get_session(request.session_id)
 		if not session:
 			session_id = state.memory_system.create_session(request.user_id, request.title or "New Chat")
@@ -43,11 +47,16 @@ async def chat_endpoint(
 			session = state.memory_system.get_session(session_id)
 			logger().info(f"Created new session: {session_id}")
 
-		# Get medical context from memory
-		medical_context = state.history_manager.get_conversation_context(
+		# Ensure session exists in Mongo with patient/doctor context
+		ensure_session(session_id=request.session_id, patient_id=request.patient_id, doctor_id=request.doctor_id, title=request.title or "New Chat", last_activity=datetime.now(timezone.utc))
+
+		# Get enhanced medical context with STM + LTM semantic search + NVIDIA reasoning
+		medical_context = await state.history_manager.get_enhanced_conversation_context(
 			request.user_id,
-			#request.session_id,
-			#request.message
+			request.session_id,
+			request.message,
+			state.nvidia_rotator,
+			patient_id=request.patient_id
 		)
 
 		# Generate response using Gemini AI
@@ -68,7 +77,10 @@ async def chat_endpoint(
 				request.message,
 				response,
 				state.gemini_rotator,
-				state.nvidia_rotator
+				state.nvidia_rotator,
+				patient_id=request.patient_id,
+				doctor_id=request.doctor_id,
+				session_title=request.title or "New Chat"
 			)
 		except Exception as e:
 			logger().warning(f"Failed to process medical exchange: {e}")
@@ -83,7 +95,7 @@ async def chat_endpoint(
 		return ChatResponse(
 			response=response,
 			session_id=request.session_id,
-			timestamp=datetime.now(timezone.utc).isoformat(),  # Use ISO format for consistency
+			timestamp=datetime.now(timezone.utc).isoformat(),
 			medical_context=medical_context if medical_context else None
 		)
 

src/api/routes/session.py

@@ -3,10 +3,12 @@
 from datetime import datetime
 
 from fastapi import APIRouter, Depends, HTTPException
+from datetime import datetime
 
 from src.core.state import MedicalState, get_state
 from src.models.chat import SessionRequest
 from src.utils.logger import logger
+from src.data import list_patient_sessions, list_session_messages, ensure_session, delete_session, delete_session_messages
 
 router = APIRouter()
 
@@ -15,9 +17,12 @@ async def create_chat_session(
 	request: SessionRequest,
 	state: MedicalState = Depends(get_state)
 ):
-	"""Create a new chat session"""
+	"""Create a new chat session (cache + Mongo)"""
 	try:
+		logger().info(f"POST /sessions user_id={request.user_id} patient_id={request.patient_id} doctor_id={request.doctor_id}")
 		session_id = state.memory_system.create_session(request.user_id, request.title or "New Chat")
+		# Also ensure in Mongo with patient/doctor
+		ensure_session(session_id=session_id, patient_id=request.patient_id, doctor_id=request.doctor_id, title=request.title or "New Chat")
 		return {"session_id": session_id, "message": "Session created successfully"}
 	except Exception as e:
 		logger().error(f"Error creating session: {e}")
@@ -28,7 +33,7 @@ async def get_chat_session(
 	session_id: str,
 	state: MedicalState = Depends(get_state)
 ):
-	"""Get chat session details and messages"""
+	"""Get session from cache (for quick preview)"""
 	try:
 		session = state.memory_system.get_session(session_id)
 		if not session:
@@ -52,15 +57,55 @@ async def get_chat_session(
 		logger().error(f"Error getting session: {e}")
 		raise HTTPException(status_code=500, detail=str(e))
 
+@router.get("/patients/{patient_id}/sessions")
+async def list_sessions_for_patient(patient_id: str):
+	"""List sessions for a patient from Mongo"""
+	try:
+		logger().info(f"GET /patients/{patient_id}/sessions")
+		return {"sessions": list_patient_sessions(patient_id)}
+	except Exception as e:
+		logger().error(f"Error listing sessions: {e}")
+		raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/sessions/{session_id}/messages")
+async def list_messages_for_session(session_id: str, patient_id: str, limit: int | None = None):
+	"""List messages for a session from Mongo, verified to belong to the patient"""
+	try:
+		logger().info(f"GET /sessions/{session_id}/messages patient_id={patient_id} limit={limit}")
+		msgs = list_session_messages(session_id, patient_id=patient_id, limit=limit)
+		# ensure JSON-friendly timestamps
+		for m in msgs:
+			if isinstance(m.get("timestamp"), datetime):
+				m["timestamp"] = m["timestamp"].isoformat()
+			m["_id"] = str(m["_id"]) if "_id" in m else None
+		return {"messages": msgs}
+	except Exception as e:
+		logger().error(f"Error listing messages: {e}")
+		raise HTTPException(status_code=500, detail=str(e))
+
 @router.delete("/sessions/{session_id}")
 async def delete_chat_session(
 	session_id: str,
 	state: MedicalState = Depends(get_state)
 ):
-	"""Delete a chat session"""
+	"""Delete a chat session from both memory system and MongoDB"""
 	try:
+		logger().info(f"DELETE /sessions/{session_id}")
+
+		# Delete from memory system
 		state.memory_system.delete_session(session_id)
-		return {"message": "Session deleted successfully"}
+
+		# Delete from MongoDB
+		session_deleted = delete_session(session_id)
+		messages_deleted = delete_session_messages(session_id)
+
+		logger().info(f"Deleted session {session_id}: session={session_deleted}, messages={messages_deleted}")
+
+		return {
+			"message": "Session deleted successfully",
+			"session_deleted": session_deleted,
+			"messages_deleted": messages_deleted
+		}
 	except Exception as e:
 		logger().error(f"Error deleting session: {e}")
 		raise HTTPException(status_code=500, detail=str(e))

src/api/routes/user.py

@@ -3,8 +3,9 @@
 from fastapi import APIRouter, Depends, HTTPException
 
 from src.core.state import MedicalState, get_state
-from src.models.user import UserProfileRequest
 from src.utils.logger import logger
+from src.models.user import UserProfileRequest, PatientCreateRequest, PatientUpdateRequest, DoctorCreateRequest
+from src.data import create_account, create_doctor, get_doctor_by_name, search_doctors, get_all_doctors
 
 router = APIRouter()
 
@@ -15,12 +16,25 @@ async def create_user_profile(
 ):
 	"""Create or update user profile"""
 	try:
+		# Persist to in-memory profile (existing behavior)
 		user = state.memory_system.create_user(request.user_id, request.name)
 		user.set_preference("role", request.role)
 		if request.specialty:
 			user.set_preference("specialty", request.specialty)
+		if request.medical_roles:
+			user.set_preference("medical_roles", request.medical_roles)
 
-		return {"message": "User profile created successfully", "user_id": request.user_id}
+		# Persist to MongoDB accounts collection
+		account_doc = {
+			"user_id": request.user_id,
+			"name": request.name,
+			"role": request.role,
+			"medical_roles": request.medical_roles or [request.role] if request.role else [],
+			"specialty": request.specialty or None,
+		}
+		account_id = create_account(account_doc)
+
+		return {"message": "User profile created successfully", "user_id": request.user_id, "account_id": account_id}
 	except Exception as e:
 		logger().error(f"Error creating user profile: {e}")
 		raise HTTPException(status_code=500, detail=str(e))
@@ -44,6 +58,7 @@ async def get_user_profile(
 				"name": user.name,
 				"role": user.preferences.get("role", "Unknown"),
 				"specialty": user.preferences.get("specialty", ""),
+				"medical_roles": user.preferences.get("medical_roles", []),
 				"created_at": user.created_at,
 				"last_seen": user.last_seen
 			},
@@ -63,3 +78,120 @@ async def get_user_profile(
 	except Exception as e:
 		logger().error(f"Error getting user profile: {e}")
 		raise HTTPException(status_code=500, detail=str(e))
+
+# -------------------- Patient APIs --------------------
+from src.data import get_patient_by_id, create_patient, update_patient_profile, search_patients
+
+@router.get("/patients/search")
+async def search_patients_route(q: str, limit: int = 20):
+	try:
+		logger().info(f"GET /patients/search q='{q}' limit={limit}")
+		results = search_patients(q, limit=limit)
+		logger().info(f"Search returned {len(results)} results")
+		return {"results": results}
+	except Exception as e:
+		logger().error(f"Error searching patients: {e}")
+		raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/patients/{patient_id}")
+async def get_patient(patient_id: str):
+	try:
+		logger().info(f"GET /patients/{patient_id}")
+		patient = get_patient_by_id(patient_id)
+		if not patient:
+			raise HTTPException(status_code=404, detail="Patient not found")
+		patient["_id"] = str(patient.get("_id")) if patient.get("_id") else None
+		return patient
+	except HTTPException:
+		raise
+	except Exception as e:
+		logger().error(f"Error getting patient: {e}")
+		raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/patients")
+async def create_patient_profile(req: PatientCreateRequest):
+	try:
+		logger().info(f"POST /patients name={req.name}")
+		patient = create_patient(
+			name=req.name,
+			age=req.age,
+			sex=req.sex,
+			address=req.address,
+			phone=req.phone,
+			email=req.email,
+			medications=req.medications,
+			past_assessment_summary=req.past_assessment_summary,
+			assigned_doctor_id=req.assigned_doctor_id
+		)
+		patient["_id"] = str(patient.get("_id")) if patient.get("_id") else None
+		logger().info(f"Created patient {patient.get('name')} id={patient.get('patient_id')}")
+		return patient
+	except Exception as e:
+		logger().error(f"Error creating patient: {e}")
+		raise HTTPException(status_code=500, detail=str(e))
+
+@router.patch("/patients/{patient_id}")
+async def update_patient(patient_id: str, req: PatientUpdateRequest):
+	try:
+		payload = {k: v for k, v in req.model_dump().items() if v is not None}
+		logger().info(f"PATCH /patients/{patient_id} fields={list(payload.keys())}")
+		modified = update_patient_profile(patient_id, payload)
+		if modified == 0:
+			return {"message": "No changes"}
+		return {"message": "Updated"}
+	except Exception as e:
+		logger().error(f"Error updating patient: {e}")
+		raise HTTPException(status_code=500, detail=str(e))
+
+# -------------------- Doctor APIs --------------------
+@router.post("/doctors")
+async def create_doctor_profile(req: DoctorCreateRequest):
+	try:
+		logger().info(f"POST /doctors name={req.name}")
+		doctor_id = create_doctor(
+			name=req.name,
+			role=req.role,
+			specialty=req.specialty,
+			medical_roles=req.medical_roles
+		)
+		logger().info(f"Created doctor {req.name} id={doctor_id}")
+		return {"doctor_id": doctor_id, "name": req.name}
+	except Exception as e:
+		logger().error(f"Error creating doctor: {e}")
+		raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/doctors/{doctor_name}")
+async def get_doctor(doctor_name: str):
+	try:
+		logger().info(f"GET /doctors/{doctor_name}")
+		doctor = get_doctor_by_name(doctor_name)
+		if not doctor:
+			raise HTTPException(status_code=404, detail="Doctor not found")
+		return doctor
+	except HTTPException:
+		raise
+	except Exception as e:
+		logger().error(f"Error getting doctor: {e}")
+		raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/doctors/search")
+async def search_doctors_route(q: str, limit: int = 10):
+	try:
+		logger().info(f"GET /doctors/search q='{q}' limit={limit}")
+		results = search_doctors(q, limit=limit)
+		logger().info(f"Doctor search returned {len(results)} results")
+		return {"results": results}
+	except Exception as e:
+		logger().error(f"Error searching doctors: {e}")
+		raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/doctors")
+async def get_all_doctors_route(limit: int = 50):
+	try:
+		logger().info(f"GET /doctors limit={limit}")
+		results = get_all_doctors(limit=limit)
+		logger().info(f"Retrieved {len(results)} doctors")
+		return {"results": results}
+	except Exception as e:
+		logger().error(f"Error getting all doctors: {e}")
+		raise HTTPException(status_code=500, detail=str(e))

src/core/memory/history.py

@@ -0,0 +1,322 @@
+# core/memory/history.py
+
+import json
+from typing import Any
+
+import numpy as np
+from datetime import datetime, timezone
+
+from src.services.nvidia import nvidia_chat
+from src.services.summariser import (summarise_qa_with_gemini,
+                                     summarise_qa_with_nvidia)
+from src.utils.embeddings import EmbeddingClient
+from src.utils.logger import get_logger
+from src.data import save_memory_summary, save_chat_message, ensure_session, get_recent_memory_summaries, search_memory_summaries_semantic
+
+logger = get_logger("MED_HISTORY")
+
+def _safe_json(s: str) -> Any:
+	try:
+		return json.loads(s)
+	except Exception:
+		# Try to extract a JSON object from text
+		start = s.find("{")
+		end = s.rfind("}")
+		if start != -1 and end != -1 and end > start:
+			try:
+				return json.loads(s[start:end+1])
+			except Exception:
+				return {}
+		return {}
+
+async def files_relevance(question: str, file_summaries: list[dict[str, str]], rotator) -> dict[str, bool]:
+	"""
+	Ask NVIDIA model to mark each file as relevant (true) or not (false) for the question.
+	Returns {filename: bool}
+	"""
+	sys = "You classify file relevance. Return STRICT JSON only with shape {\"relevance\":[{\"filename\":\"...\",\"relevant\":true|false}]}."
+	items = [{"filename": f["filename"], "summary": f.get("summary","")} for f in file_summaries]
+	user = f"Question: {question}\n\nFiles:\n{json.dumps(items, ensure_ascii=False)}\n\nReturn JSON only."
+	out = await nvidia_chat(sys, user, rotator)
+	data = _safe_json(out) or {}
+	rels = {}
+	for row in data.get("relevance", []):
+		fn = row.get("filename")
+		rv = row.get("relevant")
+		if isinstance(fn, str) and isinstance(rv, bool):
+			rels[fn] = rv
+	# If parsing failed, default to considering all files possibly relevant
+	if not rels and file_summaries:
+		rels = {f["filename"]: True for f in file_summaries}
+	return rels
+
+def _cosine(a: np.ndarray, b: np.ndarray) -> float:
+	denom = (np.linalg.norm(a) * np.linalg.norm(b)) or 1.0
+	return float(np.dot(a, b) / denom)
+
+def _as_text(block: str) -> str:
+	return block.strip()
+
+async def related_recent_and_semantic_context(user_id: str, question: str, memory, embedder: EmbeddingClient, topk_sem: int = 3) -> tuple[str, str]:
+	"""
+	Returns (recent_related_text, semantic_related_text).
+	- recent_related_text: NVIDIA checks the last 3 summaries for direct relatedness.
+	- semantic_related_text: cosine-sim search over the remaining 17 summaries (top-k).
+	"""
+	recent3 = memory.recent(user_id, 3)
+	rest17 = memory.rest(user_id, 3)
+
+	recent_text = ""
+	if recent3:
+		sys = "Pick only items that directly relate to the new question. Output the selected items verbatim, no commentary. If none, output nothing."
+		numbered = [{"id": i+1, "text": s} for i, s in enumerate(recent3)]
+		user = f"Question: {question}\nCandidates:\n{json.dumps(numbered, ensure_ascii=False)}\nSelect any related items and output ONLY their 'text' lines concatenated."
+		key = None  # We'll let robust_post_json handle rotation via rotator param
+	# Semantic over rest17
+	sem_text = ""
+	if rest17:
+		qv = np.array(embedder.embed([question])[0], dtype="float32")
+		mats = embedder.embed([_as_text(s) for s in rest17])
+		sims = [(_cosine(qv, np.array(v, dtype="float32")), s) for v, s in zip(mats, rest17)]
+		sims.sort(key=lambda x: x[0], reverse=True)
+		top = [s for (sc, s) in sims[:topk_sem] if sc > 0.15]  # small threshold
+		if top:
+			sem_text = "\n\n".join(top)
+	# Return recent empty (to be filled by caller using NVIDIA), and semantic text
+	return ("", sem_text)
+
+class MedicalHistoryManager:
+	"""
+	Enhanced medical history manager that works with the new memory system
+	"""
+	def __init__(self, memory, embedder: EmbeddingClient | None = None):
+		self.memory = memory
+		self.embedder = embedder
+
+	async def process_medical_exchange(self, user_id: str, session_id: str, question: str, answer: str, gemini_rotator, nvidia_rotator=None, *, patient_id: str | None = None, doctor_id: str | None = None, session_title: str | None = None) -> str:
+		"""
+		Process a medical Q&A exchange and store it in memory and MongoDB
+		"""
+		try:
+			# Check if we have valid API keys
+			if not gemini_rotator or not gemini_rotator.get_key() or gemini_rotator.get_key() == "":
+				logger.info("No valid Gemini API keys available, using fallback summary")
+				summary = f"q: {question}\na: {answer}"
+			else:
+				# Try to create summary using Gemini (preferred) or NVIDIA as fallback
+				try:
+					# First try Gemini
+					summary = await summarise_qa_with_gemini(question, answer, gemini_rotator)
+					if not summary or summary.strip() == "":
+						# Fallback to NVIDIA if Gemini fails
+						if nvidia_rotator and nvidia_rotator.get_key():
+							summary = await summarise_qa_with_nvidia(question, answer, nvidia_rotator)
+							if not summary or summary.strip() == "":
+								summary = f"q: {question}\na: {answer}"
+						else:
+							summary = f"q: {question}\na: {answer}"
+				except Exception as e:
+					logger.warning(f"Failed to create AI summary: {e}")
+					summary = f"q: {question}\na: {answer}"
+
+			# Short-term cache under patient_id when available
+			cache_key = patient_id or user_id
+			self.memory.add(cache_key, summary)
+
+			# Add to session history in cache
+			self.memory.add_message_to_session(session_id, "user", question)
+			self.memory.add_message_to_session(session_id, "assistant", answer)
+
+			# Persist to MongoDB with patient/doctor context
+			if patient_id and doctor_id:
+				ensure_session(session_id=session_id, patient_id=patient_id, doctor_id=doctor_id, title=session_title or "New Chat", last_activity=datetime.now(timezone.utc))
+				save_chat_message(session_id=session_id, patient_id=patient_id, doctor_id=doctor_id, role="user", content=question)
+				save_chat_message(session_id=session_id, patient_id=patient_id, doctor_id=doctor_id, role="assistant", content=answer)
+				
+				# Generate embedding for semantic search
+				embedding = None
+				if self.embedder:
+					try:
+						embedding = self.embedder.embed([summary])[0]
+					except Exception as e:
+						logger.warning(f"Failed to generate embedding for summary: {e}")
+				
+				save_memory_summary(patient_id=patient_id, doctor_id=doctor_id, summary=summary, embedding=embedding)
+
+			# Update session title if it's the first message
+			session = self.memory.get_session(session_id)
+			if session and len(session.messages) == 2:  # Just user + assistant
+				# Generate a title using NVIDIA API if available
+				try:
+					from src.services.summariser import summarise_title_with_nvidia
+					title = await summarise_title_with_nvidia(question, nvidia_rotator, max_words=5)
+					if not title or title.strip() == "":
+						title = question[:50] + ("..." if len(question) > 50 else "")
+				except Exception as e:
+					logger.warning(f"Failed to generate title with NVIDIA: {e}")
+					title = question[:50] + ("..." if len(question) > 50 else "")
+				
+				self.memory.update_session_title(session_id, title)
+				
+				# Also update the session in MongoDB
+				if patient_id and doctor_id:
+					ensure_session(session_id=session_id, patient_id=patient_id, doctor_id=doctor_id, title=title, last_activity=datetime.now(timezone.utc))
+
+			return summary
+
+		except Exception as e:
+			logger.error(f"Error processing medical exchange: {e}")
+			# Fallback: store without summary
+			summary = f"q: {question}\na: {answer}"
+			cache_key = patient_id or user_id
+			self.memory.add(cache_key, summary)
+			self.memory.add_message_to_session(session_id, "user", question)
+			self.memory.add_message_to_session(session_id, "assistant", answer)
+			return summary
+
+	def get_conversation_context(self, user_id: str, session_id: str, question: str, *, patient_id: str | None = None) -> str:
+		"""
+		Get relevant conversation context combining short-term cache (3) and long-term Mongo (20)
+		"""
+		# Short-term summaries
+		cache_key = patient_id or user_id
+		recent_qa = self.memory.recent(cache_key, 3)
+
+		# Long-term summaries from Mongo (exclude ones already likely in cache by time order)
+		long_term = []
+		if patient_id:
+			try:
+				long_term = get_recent_memory_summaries(patient_id, limit=20)
+			except Exception as e:
+				logger.warning(f"Failed to fetch long-term memory: {e}")
+
+		# Get current session messages for context
+		session = self.memory.get_session(session_id)
+		session_context = ""
+		if session:
+			recent_messages = session.get_messages(10)
+			session_context = "\n".join([f"{msg['role']}: {msg['content']}" for msg in recent_messages])
+
+		# Combine context
+		context_parts = []
+		combined = []
+		if long_term:
+			combined.extend(long_term[::-1])  # oldest to newest within limit
+		if recent_qa:
+			combined.extend(recent_qa[::-1])
+		if combined:
+			context_parts.append("Recent medical context:\n" + "\n".join(combined[-20:]))
+		if session_context:
+			context_parts.append("Current conversation:\n" + session_context)
+
+		return "\n\n".join(context_parts) if context_parts else ""
+
+	async def get_enhanced_conversation_context(self, user_id: str, session_id: str, question: str, nvidia_rotator, *, patient_id: str | None = None) -> str:
+		"""
+		Enhanced context retrieval combining STM (3) + LTM semantic search (2) with NVIDIA reasoning.
+		Returns context that NVIDIA model can use to decide between STM and LTM information.
+		"""
+		cache_key = patient_id or user_id
+		
+		# Get STM summaries (recent 3)
+		recent_qa = self.memory.recent(cache_key, 3)
+		
+		# Get LTM semantic matches (top 2 most similar)
+		ltm_semantic = []
+		if patient_id and self.embedder:
+			try:
+				query_embedding = self.embedder.embed([question])[0]
+				ltm_results = search_memory_summaries_semantic(
+					patient_id=patient_id,
+					query_embedding=query_embedding,
+					limit=2,
+					similarity_threshold=0.5  # >= 50% semantic similarity
+				)
+				ltm_semantic = [result["summary"] for result in ltm_results]
+			except Exception as e:
+				logger.warning(f"Failed to perform LTM semantic search: {e}")
+		
+		# Get current session messages for context
+		session = self.memory.get_session(session_id)
+		session_context = ""
+		if session:
+			recent_messages = session.get_messages(10)
+			session_context = "\n".join([f"{msg['role']}: {msg['content']}" for msg in recent_messages])
+		
+		# Use NVIDIA to reason about STM relevance
+		relevant_stm = []
+		if recent_qa and nvidia_rotator:
+			try:
+				sys = "You are a medical AI assistant. Select only the most relevant recent medical context that directly relates to the new question. Return the selected items verbatim, no commentary. If none are relevant, return nothing."
+				numbered = [{"id": i+1, "text": s} for i, s in enumerate(recent_qa)]
+				user = f"Question: {question}\n\nRecent medical context (last 3 exchanges):\n{json.dumps(numbered, ensure_ascii=False)}\n\nSelect any relevant items and output ONLY their 'text' lines concatenated."
+				relevant_stm_text = await nvidia_chat(sys, user, nvidia_rotator)
+				if relevant_stm_text and relevant_stm_text.strip():
+					relevant_stm = [relevant_stm_text.strip()]
+			except Exception as e:
+				logger.warning(f"Failed to get NVIDIA STM reasoning: {e}")
+				# Fallback to all recent QA if NVIDIA fails
+				relevant_stm = recent_qa
+		else:
+			relevant_stm = recent_qa
+		
+		# Combine all relevant context
+		context_parts = []
+		
+		# Add STM context
+		if relevant_stm:
+			context_parts.append("Recent relevant medical context (STM):\n" + "\n".join(relevant_stm))
+		
+		# Add LTM semantic context
+		if ltm_semantic:
+			context_parts.append("Semantically relevant medical history (LTM):\n" + "\n".join(ltm_semantic))
+		
+		# Add current session context
+		if session_context:
+			context_parts.append("Current conversation:\n" + session_context)
+		
+		return "\n\n".join(context_parts) if context_parts else ""
+
+	def get_user_medical_history(self, user_id: str, limit: int = 20) -> list[str]:
+		"""
+		Get user's medical history (QA summaries)
+		"""
+		return self.memory.all(user_id)[-limit:]
+
+	def search_medical_context(self, user_id: str, query: str, top_k: int = 5) -> list[str]:
+		"""
+		Search through user's medical context for relevant information
+		"""
+		if not self.embedder:
+			# Fallback to simple text search
+			all_context = self.memory.all(user_id)
+			query_lower = query.lower()
+			relevant = [ctx for ctx in all_context if query_lower in ctx.lower()]
+			return relevant[:top_k]
+
+		try:
+			# Semantic search using embeddings
+			query_embedding = np.array(self.embedder.embed([query])[0], dtype="float32")
+			all_context = self.memory.all(user_id)
+
+			if not all_context:
+				return []
+
+			context_embeddings = self.embedder.embed(all_context)
+			similarities = []
+
+			for i, ctx_emb in enumerate(context_embeddings):
+				sim = _cosine(query_embedding, np.array(ctx_emb, dtype="float32"))
+				similarities.append((sim, all_context[i]))
+
+			# Sort by similarity and return top-k
+			similarities.sort(key=lambda x: x[0], reverse=True)
+			return [ctx for sim, ctx in similarities[:top_k] if sim > 0.1]
+
+		except Exception as e:
+			logger.error(f"Error in semantic search: {e}")
+			# Fallback to simple search
+			all_context = self.memory.all(user_id)
+			query_lower = query.lower()
+			relevant = [ctx for ctx in all_context if query_lower in ctx.lower()]
+			return relevant[:top_k]

src/core/memory/memory.py

@@ -0,0 +1,210 @@
+# core/memory/memory.py
+
+import uuid
+from collections import defaultdict, deque
+from datetime import datetime, timezone
+from typing import Any
+
+from src.utils.logger import get_logger
+
+logger = get_logger("MEMORY")
+
+class ChatSession:
+	"""Represents a chat session with a user"""
+	def __init__(self, session_id: str, user_id: str, title: str = "New Chat"):
+		self.session_id = session_id
+		self.user_id = user_id
+		self.title = title
+		self.created_at = datetime.now(timezone.utc)
+		self.last_activity = datetime.now(timezone.utc)
+		self.messages: list[dict[str, Any]] = []
+
+	def add_message(self, role: str, content: str, metadata: dict | None = None):
+		"""Add a message to the session"""
+		message = {
+			"id": str(uuid.uuid4()),
+			"role": role,  # "user" or "assistant"
+			"content": content,
+			"timestamp": datetime.now(timezone.utc),
+			"metadata": metadata or {}
+		}
+		self.messages.append(message)
+		self.last_activity = datetime.now(timezone.utc)
+
+	def get_messages(self, limit: int | None = None) -> list[dict[str, Any]]:
+		"""Get messages from the session, optionally limited"""
+		if limit is None:
+			return self.messages
+		return self.messages[-limit:]
+
+	def update_title(self, title: str):
+		"""Update the session title"""
+		self.title = title
+		self.last_activity = datetime.now(timezone.utc)
+
+class UserProfile:
+	"""Represents a user profile with multiple chat sessions"""
+	def __init__(self, user_id: str, name: str = "Anonymous"):
+		self.user_id = user_id
+		self.name = name
+		self.created_at = datetime.now(timezone.utc)
+		self.last_seen = datetime.now(timezone.utc)
+		self.preferences: dict[str, Any] = {}
+
+	def update_activity(self):
+		"""Update last seen timestamp"""
+		self.last_seen = datetime.now(timezone.utc)
+
+	def set_preference(self, key: str, value: Any):
+		"""Set a user preference"""
+		self.preferences[key] = value
+
+	@property
+	def role(self) -> str:
+		"""Get user role from preferences"""
+		return self.preferences.get("role", "Unknown")
+
+class MemoryLRU:
+	"""
+	Enhanced LRU-like memory system supporting:
+	- Multiple users with profiles
+	- Multiple chat sessions per user
+	- Chat history and continuity
+	- Medical context summaries
+	"""
+	def __init__(self, capacity: int = 20, max_sessions_per_user: int = 10):
+		self.capacity = capacity
+		self.max_sessions_per_user = max_sessions_per_user
+
+		# User profiles and sessions
+		self._users: dict[str, UserProfile] = {}
+		self._sessions: dict[str, ChatSession] = {}
+		self._user_sessions: dict[str, list[str]] = defaultdict(list)
+
+		# Medical context summaries (QA pairs)
+		self._qa_store: dict[str, deque] = defaultdict(lambda: deque(maxlen=self.capacity))
+
+	def create_user(self, user_id: str, name: str = "Anonymous") -> UserProfile:
+		"""Create a new user profile"""
+		if user_id not in self._users:
+			user = UserProfile(user_id, name)
+			self._users[user_id] = user
+		return self._users[user_id]
+
+	def get_user(self, user_id: str) -> UserProfile | None:
+		"""Get user profile by ID"""
+		user = self._users.get(user_id)
+		if user:
+			user.update_activity()
+		return user
+
+	def create_session(self, user_id: str, title: str = "New Chat") -> str:
+		"""Create a new chat session for a user"""
+		# Ensure user exists
+		if user_id not in self._users:
+			self.create_user(user_id)
+
+		# Create session
+		session_id = str(uuid.uuid4())
+		session = ChatSession(session_id, user_id, title)
+		self._sessions[session_id] = session
+
+		# Add to user's session list
+		user_sessions = self._user_sessions[user_id]
+		user_sessions.append(session_id)
+
+		# Enforce max sessions per user
+		if len(user_sessions) > self.max_sessions_per_user:
+			oldest_session = user_sessions.pop(0)
+			if oldest_session in self._sessions:
+				del self._sessions[oldest_session]
+
+		return session_id
+
+	def get_session(self, session_id: str) -> ChatSession | None:
+		"""Get a chat session by ID"""
+		return self._sessions.get(session_id)
+
+	def get_user_sessions(self, user_id: str) -> list[ChatSession]:
+		"""Get all sessions for a user"""
+		session_ids = self._user_sessions.get(user_id, [])
+		sessions = []
+		for sid in session_ids:
+			if sid in self._sessions:
+				sessions.append(self._sessions[sid])
+		# Sort by last activity (most recent first)
+		sessions.sort(key=lambda x: x.last_activity, reverse=True)
+		return sessions
+
+	def add_message_to_session(self, session_id: str, role: str, content: str, metadata: dict | None = None):
+		"""Add a message to a specific session"""
+		session = self._sessions.get(session_id)
+		if session:
+			session.add_message(role, content, metadata)
+
+	def update_session_title(self, session_id: str, title: str):
+		"""Update the title of a session"""
+		session = self._sessions.get(session_id)
+		if session:
+			session.update_title(title)
+
+	def delete_session(self, session_id: str):
+		"""Delete a chat session"""
+		if session_id in self._sessions:
+			session = self._sessions[session_id]
+			user_id = session.user_id
+
+			# Remove from user's session list
+			if user_id in self._user_sessions:
+				self._user_sessions[user_id] = [s for s in self._user_sessions[user_id] if s != session_id]
+
+			# Delete session
+			del self._sessions[session_id]
+
+	def add(self, user_id: str, qa_summary: str):
+		"""Add a QA summary to the medical context store"""
+		self._qa_store[user_id].append(qa_summary)
+
+	def recent(self, user_id: str, n: int = 3) -> list[str]:
+		"""Get recent QA summaries for medical context"""
+		d = self._qa_store[user_id]
+		if not d:
+			return []
+		return list(d)[-n:][::-1]
+
+	def rest(self, user_id: str, skip_n: int = 3) -> list[str]:
+		"""Get older QA summaries for medical context"""
+		d = self._qa_store[user_id]
+		if not d:
+			return []
+		return list(d)[:-skip_n] if len(d) > skip_n else []
+
+	def all(self, user_id: str) -> list[str]:
+		"""Get all QA summaries for medical context"""
+		return list(self._qa_store[user_id])
+
+	def clear(self, user_id: str) -> None:
+		"""Clear all cached summaries for the given user"""
+		if user_id in self._qa_store:
+			self._qa_store[user_id].clear()
+
+	def get_medical_context(self, user_id: str, session_id: str, question: str) -> str:
+		"""Get relevant medical context for a question"""
+		# Get recent QA summaries
+		recent_qa = self.recent(user_id, 5)
+
+		# Get current session messages for context
+		session = self.get_session(session_id)
+		session_context = ""
+		if session:
+			recent_messages = session.get_messages(10)
+			session_context = "\n".join([f"{msg['role']}: {msg['content']}" for msg in recent_messages])
+
+		# Combine context
+		context_parts = []
+		if recent_qa:
+			context_parts.append("Recent medical context:\n" + "\n".join(recent_qa))
+		if session_context:
+			context_parts.append("Current conversation:\n" + session_context)
+
+		return "\n\n".join(context_parts) if context_parts else ""

src/core/state.py

@@ -30,6 +30,8 @@ class MedicalState:
 		"""Initializes all core application components."""
 		self.memory_system = MemoryLRU(max_sessions_per_user=20)
 		self.embedding_client = EmbeddingClient(model_name="all-MiniLM-L6-v2", dimension=384)
+		# Keep only 3 short-term summaries/messages in cache
+		#self.memory_system = MemoryLRU(capacity=3, max_sessions_per_user=20)
 		self.history_manager = MedicalHistoryManager(self.memory_system, self.embedding_client)
 		self.gemini_rotator = APIKeyRotator("GEMINI_API_", max_slots=5)
 		self.nvidia_rotator = APIKeyRotator("NVIDIA_API_", max_slots=5)

src/data/__init__.py

@@ -0,0 +1,55 @@
+# data/__init__.py
+"""
+Data layer for MongoDB operations.
+Organized into specialized modules for different data types.
+"""
+
+from .connection import get_database, get_collection, close_connection
+from .session import *
+from .user import *
+from .message import *
+from .patient import *
+from .medical import *
+from .utils import create_index, backup_collection
+
+__all__ = [
+    # Connection
+    'get_database',
+    'get_collection', 
+    'close_connection',
+    # Session functions
+    'create_chat_session',
+    'get_user_sessions',
+    'ensure_session',
+    'list_patient_sessions',
+    'delete_session',
+    'delete_session_messages',
+    'delete_old_sessions',
+    # User functions
+    'create_account',
+    'update_account',
+    'get_account_frame',
+    'create_doctor',
+    'get_doctor_by_name',
+    'search_doctors',
+    'get_all_doctors',
+    # Message functions
+    'add_message',
+    'get_session_messages',
+    'save_chat_message',
+    'list_session_messages',
+    # Patient functions
+    'get_patient_by_id',
+    'create_patient',
+    'update_patient_profile',
+    'search_patients',
+    # Medical functions
+    'create_medical_record',
+    'get_user_medical_records',
+    'save_memory_summary',
+    'get_recent_memory_summaries',
+    'search_memory_summaries_semantic',
+    # Utility functions
+    'create_index',
+    'backup_collection',
+]

src/data/connection.py

@@ -0,0 +1,57 @@
+# data/connection.py
+"""
+MongoDB connection management and base database operations.
+"""
+
+import os
+from typing import Any
+
+from pymongo import MongoClient
+from pymongo.collection import Collection
+from pymongo.database import Database
+
+from src.utils.logger import get_logger
+
+logger = get_logger("MONGO")
+
+# Global client instance
+_mongo_client: MongoClient | None = None
+
+# Collection Names
+ACCOUNTS_COLLECTION = "accounts"
+CHAT_SESSIONS_COLLECTION = "chat_sessions"
+CHAT_MESSAGES_COLLECTION = "chat_messages"
+MEDICAL_RECORDS_COLLECTION = "medical_records"
+MEDICAL_MEMORY_COLLECTION = "medical_memory"
+PATIENTS_COLLECTION = "patients"
+
+
+def get_database() -> Database:
+    """Get database instance with connection management"""
+    global _mongo_client
+    if _mongo_client is None:
+        CONNECTION_STRING = os.getenv("MONGO_USER", "mongodb://127.0.0.1:27017/")  # fall back to local host if no user is provided
+        try:
+            logger.info("Initializing MongoDB connection")
+            _mongo_client = MongoClient(CONNECTION_STRING)
+        except Exception as e:
+            logger.error(f"Failed to connect to MongoDB: {str(e)}")
+            # Pass the error down, code that calls this function should handle it
+            raise e
+    db_name = os.getenv("USER_DB", "medicaldiagnosissystem")
+    return _mongo_client[db_name]
+
+
+def close_connection():
+    """Close MongoDB connection"""
+    global _mongo_client
+    if _mongo_client is not None:
+        # Close the connection and reset the client
+        _mongo_client.close()
+        _mongo_client = None
+
+
+def get_collection(name: str, /) -> Collection:
+    """Get a MongoDB collection by name"""
+    db = get_database()
+    return db.get_collection(name)

src/data/medical/__init__.py

@@ -0,0 +1,20 @@
+# data/medical/__init__.py
+"""
+Medical records and memory management operations for MongoDB.
+"""
+
+from .operations import (
+    create_medical_record,
+    get_user_medical_records,
+    save_memory_summary,
+    get_recent_memory_summaries,
+    search_memory_summaries_semantic,
+)
+
+__all__ = [
+    'create_medical_record',
+    'get_user_medical_records',
+    'save_memory_summary',
+    'get_recent_memory_summaries',
+    'search_memory_summaries_semantic',
+]

src/data/medical/operations.py

@@ -0,0 +1,133 @@
+# data/medical/operations.py
+"""
+Medical records and memory management operations for MongoDB.
+"""
+
+from datetime import datetime, timezone
+from typing import Any
+
+from pymongo import ASCENDING, DESCENDING
+
+from ..connection import get_collection, MEDICAL_RECORDS_COLLECTION, MEDICAL_MEMORY_COLLECTION
+from src.utils.logger import get_logger
+
+logger = get_logger("MEDICAL_OPS")
+
+
+def create_medical_record(
+    record_data: dict[str, Any],
+    /,
+    *,
+    collection_name: str = MEDICAL_RECORDS_COLLECTION
+) -> str:
+    """Create a new medical record"""
+    collection = get_collection(collection_name)
+    now = datetime.now(timezone.utc)
+    record_data["created_at"] = now
+    record_data["updated_at"] = now
+    result = collection.insert_one(record_data)
+    return str(result.inserted_id)
+
+
+def get_user_medical_records(
+    user_id: str,
+    /,
+    *,
+    collection_name: str = MEDICAL_RECORDS_COLLECTION
+) -> list[dict[str, Any]]:
+    """Get medical records for a specific user"""
+    collection = get_collection(collection_name)
+    return list(collection.find({"user_id": user_id}).sort("created_at", ASCENDING))
+
+
+def save_memory_summary(
+    *,
+    patient_id: str,
+    doctor_id: str,
+    summary: str,
+    embedding: list[float] | None = None,
+    created_at: datetime | None = None,
+    collection_name: str = MEDICAL_MEMORY_COLLECTION
+) -> str:
+    collection = get_collection(collection_name)
+    ts = created_at or datetime.now(timezone.utc)
+    doc = {
+        "patient_id": patient_id,
+        "doctor_id": doctor_id,
+        "summary": summary,
+        "created_at": ts
+    }
+    if embedding is not None:
+        doc["embedding"] = embedding
+    result = collection.insert_one(doc)
+    return str(result.inserted_id)
+
+
+def get_recent_memory_summaries(
+    patient_id: str,
+    /,
+    *,
+    limit: int = 20,
+    collection_name: str = MEDICAL_MEMORY_COLLECTION
+) -> list[str]:
+    collection = get_collection(collection_name)
+    docs = list(collection.find({"patient_id": patient_id}).sort("created_at", DESCENDING).limit(limit))
+    return [d.get("summary", "") for d in docs]
+
+
+def search_memory_summaries_semantic(
+    patient_id: str,
+    query_embedding: list[float],
+    /,
+    *,
+    limit: int = 5,
+    similarity_threshold: float = 0.5,  # >= 50% semantic similarity
+    collection_name: str = MEDICAL_MEMORY_COLLECTION
+) -> list[dict[str, Any]]:
+    """
+    Search memory summaries using semantic similarity with embeddings.
+    Returns list of {summary, similarity_score, created_at} sorted by similarity.
+    """
+    collection = get_collection(collection_name)
+    
+    # Get all summaries with embeddings for this patient
+    docs = list(collection.find({
+        "patient_id": patient_id,
+        "embedding": {"$exists": True}
+    }))
+    
+    if not docs:
+        return []
+    
+    # Calculate similarities
+    import numpy as np
+    query_vec = np.array(query_embedding, dtype="float32")
+    results = []
+    
+    for doc in docs:
+        embedding = doc.get("embedding")
+        if not embedding:
+            continue
+            
+        # Calculate cosine similarity
+        doc_vec = np.array(embedding, dtype="float32")
+        dot_product = np.dot(query_vec, doc_vec)
+        norm_query = np.linalg.norm(query_vec)
+        norm_doc = np.linalg.norm(doc_vec)
+        
+        if norm_query == 0 or norm_doc == 0:
+            similarity = 0.0
+        else:
+            similarity = float(dot_product / (norm_query * norm_doc))
+        
+        if similarity >= similarity_threshold:
+            results.append({
+                "summary": doc.get("summary", ""),
+                "similarity_score": similarity,
+                "created_at": doc.get("created_at"),
+                "session_id": doc.get("session_id")  # if we add this field later
+            })
+    
+    # Sort by similarity (highest first) and return top results
+    results.sort(key=lambda x: x["similarity_score"], reverse=True)
+    return results[:limit]

src/data/medical_kb.py

@@ -1,6 +1,7 @@
 # data/medical_kb.py
-# Medical Knowledge Base for the Medical AI Assistant
 
+# TODO: This should be replaced with a more robust knowledge base system that can be updated by the user.
+# Medical Knowledge Base for the Medical AI Assistant
 MEDICAL_KB = {
 	"symptoms": {
 		"fever": "Fever is a temporary increase in body temperature, often due to illness. Normal body temperature is around 98.6°F (37°C).",

src/data/message/__init__.py

@@ -0,0 +1,18 @@
+# data/message/__init__.py
+"""
+Message management operations for MongoDB.
+"""
+
+from .operations import (
+    add_message,
+    get_session_messages,
+    save_chat_message,
+    list_session_messages,
+)
+
+__all__ = [
+    'add_message',
+    'get_session_messages',
+    'save_chat_message',
+    'list_session_messages',
+]

src/data/message/operations.py

@@ -0,0 +1,124 @@
+# data/message/operations.py
+"""
+Message management operations for MongoDB.
+"""
+
+from datetime import datetime, timezone
+from typing import Any
+
+from bson import ObjectId
+from pymongo import ASCENDING
+
+from ..connection import get_collection, CHAT_SESSIONS_COLLECTION, CHAT_MESSAGES_COLLECTION
+from src.utils.logger import get_logger
+
+logger = get_logger("MESSAGE_OPS")
+
+
+def add_message(
+    session_id: str,
+    message_data: dict[str, Any],
+    /,
+    *,
+    collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> str | None:
+    """Add a message to a chat session"""
+    collection = get_collection(collection_name)
+
+    # Verify session exists first
+    session = collection.find_one({
+        "$or": [
+            {"_id": session_id},
+            {"_id": ObjectId(session_id) if ObjectId.is_valid(session_id) else None}
+        ]
+    })
+    if not session:
+        logger.error(f"Failed to add message - session not found: {session_id}")
+        raise ValueError(f"Chat session not found: {session_id}")
+
+    now = datetime.now(timezone.utc)
+    message_data["timestamp"] = now
+    result = collection.update_one(
+        {"_id": session["_id"]},
+        {
+            "$push": {"messages": message_data},
+            "$set": {"updated_at": now}
+        }
+    )
+    return str(session_id) if result.modified_count > 0 else None
+
+
+def get_session_messages(
+    session_id: str,
+    /,
+    limit: int | None = None,
+    *,
+    collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> list[dict[str, Any]]:
+    """Get messages from a specific chat session"""
+    collection = get_collection(collection_name)
+    pipeline = [
+        {"$match": {"_id": session_id}},
+        {"$unwind": "$messages"},
+        {"$sort": {"messages.timestamp": -1}}
+    ]
+    if limit:
+        pipeline.append({"$limit": limit})
+    return [doc["messages"] for doc in collection.aggregate(pipeline)]
+
+
+def save_chat_message(
+    *,
+    session_id: str,
+    patient_id: str,
+    doctor_id: str,
+    role: str,
+    content: str,
+    timestamp: datetime | None = None,
+    collection_name: str = CHAT_MESSAGES_COLLECTION
+) -> ObjectId:
+    collection = get_collection(collection_name)
+    ts = timestamp or datetime.now(timezone.utc)
+    doc = {
+        "session_id": session_id,
+        "patient_id": patient_id,
+        "doctor_id": doctor_id,
+        "role": role,
+        "content": content,
+        "timestamp": ts,
+        "created_at": ts
+    }
+    result = collection.insert_one(doc)
+    return result.inserted_id
+
+
+def list_session_messages(
+    session_id: str,
+    /,
+    *,
+    patient_id: str | None = None,
+    limit: int | None = None,
+    collection_name: str = CHAT_MESSAGES_COLLECTION
+) -> list[dict[str, Any]]:
+    collection = get_collection(collection_name)
+    
+    # First verify the session belongs to the patient
+    if patient_id:
+        session_collection = get_collection(CHAT_SESSIONS_COLLECTION)
+        session = session_collection.find_one({
+            "session_id": session_id,
+            "patient_id": patient_id
+        })
+        if not session:
+            logger.warning(f"Session {session_id} not found for patient {patient_id}")
+            return []
+    
+    # Query messages with patient_id filter if provided
+    query = {"session_id": session_id}
+    if patient_id:
+        query["patient_id"] = patient_id
+        
+    cursor = collection.find(query).sort("timestamp", ASCENDING)
+    if limit is not None:
+        cursor = cursor.limit(limit)
+    return list(cursor)

src/data/mongodb.py.backup

@@ -0,0 +1,638 @@
+# data/mongodb.py
+
+"""
+	Interface for mongodb using pymongo.
+	This file has been refactored.
+"""
+
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from bson import ObjectId
+from pandas import DataFrame
+from pymongo import ASCENDING, DESCENDING, MongoClient
+from pymongo.collection import Collection
+from pymongo.database import Database
+from pymongo.errors import DuplicateKeyError
+
+from src.utils.logger import get_logger
+import os
+
+logger = get_logger("MONGO")
+
+# Global client instance
+_mongo_client: MongoClient | None = None
+
+# Collection Names
+ACCOUNTS_COLLECTION = "accounts"
+CHAT_SESSIONS_COLLECTION = "chat_sessions"
+MEDICAL_RECORDS_COLLECTION = "medical_records"
+# DOCTORS_COLLECTION = "doctors"
+
+# Base Database Operations
+def get_database() -> Database:
+	"""Get database instance with connection management"""
+	global _mongo_client
+	if _mongo_client is None:
+		CONNECTION_STRING = os.getenv("MONGO_USER", "mongodb://127.0.0.1:27017/") # fall back to local host if no user is provided
+		try:
+			logger.info("Initializing MongoDB connection")
+			_mongo_client = MongoClient(CONNECTION_STRING)
+		except Exception as e:
+			logger.error(f"Failed to connect to MongoDB: {str(e)}")
+			# Pass the error down, code that calls this function should handle it
+			raise e
+	db_name = os.getenv("USER_DB", "medicaldiagnosissystem")
+	return _mongo_client[db_name]
+
+def close_connection():
+	"""Close MongoDB connection"""
+	global _mongo_client
+	if _mongo_client is not None:
+		# Close the connection and reset the client
+		_mongo_client.close()
+		_mongo_client = None
+
+def get_collection(name: str, /) -> Collection:
+	"""Get a MongoDB collection by name"""
+	db = get_database()
+	return db.get_collection(name)
+
+
+# Account Management
+def get_account_frame(
+	*,
+	collection_name: str = ACCOUNTS_COLLECTION
+) -> DataFrame:
+	"""Get accounts as a pandas DataFrame"""
+	return DataFrame(get_collection(collection_name).find())
+
+def create_account(
+	user_data: dict[str, Any],
+	/, *,
+	collection_name: str = ACCOUNTS_COLLECTION
+) -> str:
+	"""Create a new user account"""
+	collection = get_collection(collection_name)
+	now = datetime.now(timezone.utc)
+	user_data["created_at"] = now
+	user_data["updated_at"] = now
+	try:
+		result = collection.insert_one(user_data)
+		logger.info(f"Created new account: {result.inserted_id}")
+		return str(result.inserted_id)
+	except DuplicateKeyError as e:
+		logger.error(f"Failed to create account - duplicate key: {str(e)}")
+		raise DuplicateKeyError(f"Account already exists: {e}") from e
+
+def update_account(
+	user_id: str,
+	updates: dict[str, Any],
+	/, *,
+	collection_name: str = ACCOUNTS_COLLECTION
+) -> bool:
+	"""Update an existing user account"""
+	collection = get_collection(collection_name)
+	updates["updated_at"] = datetime.now(timezone.utc)
+	result = collection.update_one(
+		{"_id": user_id},
+		{"$set": updates}
+	)
+	return result.modified_count > 0
+
+
+# Chat Session Management
+def create_chat_session(
+	session_data: dict[str, Any],
+	/, *,
+	collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> str:
+	"""Create a new chat session"""
+	collection = get_collection(collection_name)
+	now = datetime.now(timezone.utc)
+	session_data["created_at"] = now
+	session_data["updated_at"] = now
+	if "_id" not in session_data:
+		session_data["_id"] = str(ObjectId())
+	result = collection.insert_one(session_data)
+	return str(result.inserted_id)
+
+def get_user_sessions(
+	user_id: str,
+	/,
+	limit: int = 20,
+	*,
+	collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> list[dict[str, Any]]:
+	"""Get chat sessions for a specific user"""
+	collection = get_collection(collection_name)
+	return list(collection.find(
+		{"user_id": user_id}
+	).sort("updated_at", DESCENDING).limit(limit))
+
+
+# Message History
+def add_message(
+	session_id: str,
+	message_data: dict[str, Any],
+	/, *,
+	collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> str | None:
+	"""Add a message to a chat session"""
+	collection = get_collection(collection_name)
+
+	# Verify session exists first
+	session = collection.find_one({
+		"$or": [
+			{"_id": session_id},
+			{"_id": ObjectId(session_id) if ObjectId.is_valid(session_id) else None}
+		]
+	})
+	if not session:
+		logger.error(f"Failed to add message - session not found: {session_id}")
+		raise ValueError(f"Chat session not found: {session_id}")
+
+	now = datetime.now(timezone.utc)
+	message_data["timestamp"] = now
+	result = collection.update_one(
+		{"_id": session["_id"]},
+		{
+			"$push": {"messages": message_data},
+			"$set": {"updated_at": now}
+		}
+	)
+	return str(session_id) if result.modified_count > 0 else None
+
+def get_session_messages(
+	session_id: str,
+	/,
+	limit: int | None = None,
+	*,
+	collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> list[dict[str, Any]]:
+	"""Get messages from a specific chat session"""
+	collection = get_collection(collection_name)
+	pipeline = [
+		{"$match": {"_id": session_id}},
+		{"$unwind": "$messages"},
+		{"$sort": {"messages.timestamp": -1}}
+	]
+	if limit:
+		pipeline.append({"$limit": limit})
+	return [doc["messages"] for doc in collection.aggregate(pipeline)]
+
+
+# Medical Records
+def create_medical_record(
+	record_data: dict[str, Any],
+	/, *,
+	collection_name: str = MEDICAL_RECORDS_COLLECTION
+) -> str:
+	"""Create a new medical record"""
+	collection = get_collection(collection_name)
+	now = datetime.now(timezone.utc)
+	record_data["created_at"] = now
+	record_data["updated_at"] = now
+	result = collection.insert_one(record_data)
+	return str(result.inserted_id)
+
+def get_user_medical_records(
+	user_id: str,
+	/, *,
+	collection_name: str = MEDICAL_RECORDS_COLLECTION
+) -> list[dict[str, Any]]:
+	"""Get medical records for a specific user"""
+	collection = get_collection(collection_name)
+	return list(collection.find({"user_id": user_id}).sort("created_at", ASCENDING))
+
+
+# Utility Functions
+def create_index(
+	collection_name: str,
+	field_name: str,
+	/,
+	unique: bool = False
+) -> None:
+	"""Create an index on a collection"""
+	collection = get_collection(collection_name)
+	collection.create_index([(field_name, ASCENDING)], unique=unique)
+
+def delete_old_sessions(
+	days: int = 30,
+	*,
+	collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> int:
+	"""Delete chat sessions older than specified days"""
+	collection = get_collection(collection_name)
+	cutoff = datetime.now(timezone.utc) - timedelta(days=days)
+	result = collection.delete_many({
+		"updated_at": {"$lt": cutoff}
+	})
+	if result.deleted_count > 0:
+		logger.info(f"Deleted {result.deleted_count} old sessions (>{days} days)")
+	return result.deleted_count
+
+def backup_collection(collection_name: str) -> str:
+	"""Create a backup of a collection"""
+	collection = get_collection(collection_name)
+	backup_name = f"{collection_name}_backup_{datetime.now(timezone.utc).strftime('%Y%m%d')}"
+	db = get_database()
+
+	# Drop existing backup if it exists
+	if backup_name in db.list_collection_names():
+		logger.info(f"Removing existing backup: {backup_name}")
+		db.drop_collection(backup_name)
+
+	db.create_collection(backup_name)
+	backup = db[backup_name]
+
+	doc_count = 0
+	for doc in collection.find():
+		backup.insert_one(doc)
+		doc_count += 1
+
+	logger.info(f"Created backup {backup_name} with {doc_count} documents")
+	return backup_name
+
+# New: Chat and Medical Memory Persistence Helpers
+
+CHAT_MESSAGES_COLLECTION = "chat_messages"
+MEDICAL_MEMORY_COLLECTION = "medical_memory"
+PATIENTS_COLLECTION = "patients"
+
+
+def ensure_session(
+	*,
+	session_id: str,
+	patient_id: str,
+	doctor_id: str,
+	title: str,
+	last_activity: datetime | None = None,
+	collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> None:
+	collection = get_collection(collection_name)
+	now = datetime.now(timezone.utc)
+	collection.update_one(
+		{"session_id": session_id},
+		{"$set": {
+			"session_id": session_id,
+			"patient_id": patient_id,
+			"doctor_id": doctor_id,
+			"title": title,
+			"last_activity": (last_activity or now),
+			"updated_at": now
+		}, "$setOnInsert": {"created_at": now}},
+		upsert=True
+	)
+
+
+def save_chat_message(
+	*,
+	session_id: str,
+	patient_id: str,
+	doctor_id: str,
+	role: str,
+	content: str,
+	timestamp: datetime | None = None,
+	collection_name: str = CHAT_MESSAGES_COLLECTION
+) -> ObjectId:
+	collection = get_collection(collection_name)
+	ts = timestamp or datetime.now(timezone.utc)
+	doc = {
+		"session_id": session_id,
+		"patient_id": patient_id,
+		"doctor_id": doctor_id,
+		"role": role,
+		"content": content,
+		"timestamp": ts,
+		"created_at": ts
+	}
+	result = collection.insert_one(doc)
+	return result.inserted_id
+
+
+def list_session_messages(
+	session_id: str,
+	/,
+	*,
+	patient_id: str | None = None,
+	limit: int | None = None,
+	collection_name: str = CHAT_MESSAGES_COLLECTION
+) -> list[dict[str, Any]]:
+	collection = get_collection(collection_name)
+	
+	# First verify the session belongs to the patient
+	if patient_id:
+		session_collection = get_collection(CHAT_SESSIONS_COLLECTION)
+		session = session_collection.find_one({
+			"session_id": session_id,
+			"patient_id": patient_id
+		})
+		if not session:
+			logger.warning(f"Session {session_id} not found for patient {patient_id}")
+			return []
+	
+	# Query messages with patient_id filter if provided
+	query = {"session_id": session_id}
+	if patient_id:
+		query["patient_id"] = patient_id
+		
+	cursor = collection.find(query).sort("timestamp", ASCENDING)
+	if limit is not None:
+		cursor = cursor.limit(limit)
+	return list(cursor)
+
+
+def save_memory_summary(
+	*,
+	patient_id: str,
+	doctor_id: str,
+	summary: str,
+	embedding: list[float] | None = None,
+	created_at: datetime | None = None,
+	collection_name: str = MEDICAL_MEMORY_COLLECTION
+) -> ObjectId:
+	collection = get_collection(collection_name)
+	ts = created_at or datetime.now(timezone.utc)
+	doc = {
+		"patient_id": patient_id,
+		"doctor_id": doctor_id,
+		"summary": summary,
+		"created_at": ts
+	}
+	if embedding is not None:
+		doc["embedding"] = embedding
+	result = collection.insert_one(doc)
+	return result.inserted_id
+
+
+def get_recent_memory_summaries(
+	patient_id: str,
+	/,
+	*,
+	limit: int = 20,
+	collection_name: str = MEDICAL_MEMORY_COLLECTION
+) -> list[str]:
+	collection = get_collection(collection_name)
+	docs = list(collection.find({"patient_id": patient_id}).sort("created_at", DESCENDING).limit(limit))
+	return [d.get("summary", "") for d in docs]
+
+def search_memory_summaries_semantic(
+	patient_id: str,
+	query_embedding: list[float],
+	/,
+	*,
+	limit: int = 5,
+	similarity_threshold: float = 0.5, # >= 50% semantic similarity
+	collection_name: str = MEDICAL_MEMORY_COLLECTION
+) -> list[dict[str, Any]]:
+	"""
+	Search memory summaries using semantic similarity with embeddings.
+	Returns list of {summary, similarity_score, created_at} sorted by similarity.
+	"""
+	collection = get_collection(collection_name)
+	
+	# Get all summaries with embeddings for this patient
+	docs = list(collection.find({
+		"patient_id": patient_id,
+		"embedding": {"$exists": True}
+	}))
+	
+	if not docs:
+		return []
+	
+	# Calculate similarities
+	import numpy as np
+	query_vec = np.array(query_embedding, dtype="float32")
+	results = []
+	
+	for doc in docs:
+		embedding = doc.get("embedding")
+		if not embedding:
+			continue
+			
+		# Calculate cosine similarity
+		doc_vec = np.array(embedding, dtype="float32")
+		dot_product = np.dot(query_vec, doc_vec)
+		norm_query = np.linalg.norm(query_vec)
+		norm_doc = np.linalg.norm(doc_vec)
+		
+		if norm_query == 0 or norm_doc == 0:
+			similarity = 0.0
+		else:
+			similarity = float(dot_product / (norm_query * norm_doc))
+		
+		if similarity >= similarity_threshold:
+			results.append({
+				"summary": doc.get("summary", ""),
+				"similarity_score": similarity,
+				"created_at": doc.get("created_at"),
+				"session_id": doc.get("session_id")  # if we add this field later
+			})
+	
+	# Sort by similarity (highest first) and return top results
+	results.sort(key=lambda x: x["similarity_score"], reverse=True)
+	return results[:limit]
+
+
+def list_patient_sessions(
+	patient_id: str,
+	/,
+	*,
+	collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> list[dict[str, Any]]:
+	collection = get_collection(collection_name)
+	sessions = list(collection.find({"patient_id": patient_id}).sort("last_activity", DESCENDING))
+	# Convert ObjectId to string for JSON serialization
+	for session in sessions:
+		if "_id" in session:
+			session["_id"] = str(session["_id"])
+	return sessions
+
+def delete_session(
+	session_id: str,
+	/,
+	*,
+	collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> bool:
+	"""Delete a chat session from MongoDB"""
+	collection = get_collection(collection_name)
+	result = collection.delete_one({"session_id": session_id})
+	return result.deleted_count > 0
+
+def delete_session_messages(
+	session_id: str,
+	/,
+	*,
+	collection_name: str = CHAT_MESSAGES_COLLECTION
+) -> int:
+	"""Delete all messages for a session from MongoDB"""
+	collection = get_collection(collection_name)
+	result = collection.delete_many({"session_id": session_id})
+	return result.deleted_count
+
+# Patients helpers
+
+def _generate_patient_id() -> str:
+	# Generate zero-padded 8-digit ID
+	import random
+	return f"{random.randint(0, 99999999):08d}"
+
+def get_patient_by_id(patient_id: str) -> dict[str, Any] | None:
+	collection = get_collection(PATIENTS_COLLECTION)
+	return collection.find_one({"patient_id": patient_id})
+
+def create_patient(
+	*,
+	name: str,
+	age: int,
+	sex: str,
+	address: str | None = None,
+	phone: str | None = None,
+	email: str | None = None,
+	medications: list[str] | None = None,
+	past_assessment_summary: str | None = None,
+	assigned_doctor_id: str | None = None
+) -> dict[str, Any]:
+	collection = get_collection(PATIENTS_COLLECTION)
+	now = datetime.now(timezone.utc)
+	# Ensure unique 8-digit id
+	for _ in range(10):
+		pid = _generate_patient_id()
+		if not collection.find_one({"patient_id": pid}):
+			break
+	else:
+		raise RuntimeError("Failed to generate unique patient ID")
+	doc = {
+		"patient_id": pid,
+		"name": name,
+		"age": age,
+		"sex": sex,
+		"address": address,
+		"phone": phone,
+		"email": email,
+		"medications": medications or [],
+		"past_assessment_summary": past_assessment_summary or "",
+		"assigned_doctor_id": assigned_doctor_id,
+		"created_at": now,
+		"updated_at": now
+	}
+	collection.insert_one(doc)
+	return doc
+
+def update_patient_profile(patient_id: str, updates: dict[str, Any]) -> int:
+	collection = get_collection(PATIENTS_COLLECTION)
+	updates["updated_at"] = datetime.now(timezone.utc)
+	result = collection.update_one({"patient_id": patient_id}, {"$set": updates})
+	return result.modified_count
+
+def search_patients(query: str, limit: int = 10) -> list[dict[str, Any]]:
+	"""Search patients by name (case-insensitive starts-with/contains) or partial patient_id."""
+	collection = get_collection(PATIENTS_COLLECTION)
+	if not query:
+		return []
+	
+	logger.info(f"Searching patients with query: '{query}', limit: {limit}")
+	
+	# Build a regex for name search and patient_id partial match
+	import re
+	pattern = re.compile(re.escape(query), re.IGNORECASE)
+	
+	try:
+		cursor = collection.find({
+			"$or": [
+				{"name": {"$regex": pattern}},
+				{"patient_id": {"$regex": pattern}}
+			]
+		}).sort("name", ASCENDING).limit(limit)
+		results = []
+		for p in cursor:
+			p["_id"] = str(p.get("_id")) if p.get("_id") else None
+			results.append(p)
+		logger.info(f"Found {len(results)} patients matching query")
+		return results
+	except Exception as e:
+		logger.error(f"Error in search_patients: {e}")
+		return []
+
+# Doctor Management
+def create_doctor(
+	*,
+	name: str,
+	role: str | None = None,
+	specialty: str | None = None,
+	medical_roles: list[str] | None = None
+) -> str:
+	"""Create a new doctor profile"""
+	collection = get_collection(ACCOUNTS_COLLECTION)
+	now = datetime.now(timezone.utc)
+	doctor_doc = {
+		"name": name,
+		"role": role,
+		"specialty": specialty,
+		"medical_roles": medical_roles or [],
+		"created_at": now,
+		"updated_at": now
+	}
+	try:
+		result = collection.insert_one(doctor_doc)
+		logger.info(f"Created new doctor: {name} with id {result.inserted_id}")
+		return str(result.inserted_id)
+	except Exception as e:
+		logger.error(f"Error creating doctor: {e}")
+		raise e
+
+def get_doctor_by_name(name: str) -> dict[str, Any] | None:
+	"""Get doctor by name from accounts collection"""
+	collection = get_collection(ACCOUNTS_COLLECTION)
+	doctor = collection.find_one({
+		"name": name,
+		"role": {"$in": ["Doctor", "Healthcare Prof", "General Practitioner", "Cardiologist", "Pediatrician", "Neurologist", "Dermatologist"]}
+	})
+	if doctor:
+		doctor["_id"] = str(doctor.get("_id")) if doctor.get("_id") else None
+	return doctor
+
+def search_doctors(query: str, limit: int = 10) -> list[dict[str, Any]]:
+	"""Search doctors by name (case-insensitive contains) from accounts collection"""
+	collection = get_collection(ACCOUNTS_COLLECTION)
+	if not query:
+		return []
+	
+	logger.info(f"Searching doctors with query: '{query}', limit: {limit}")
+	
+	# Build a regex for name search
+	import re
+	pattern = re.compile(re.escape(query), re.IGNORECASE)
+	
+	try:
+		cursor = collection.find({
+			"name": {"$regex": pattern},
+			"role": {"$in": ["Doctor", "Healthcare Prof", "General Practitioner", "Cardiologist", "Pediatrician", "Neurologist", "Dermatologist"]}
+		}).sort("name", ASCENDING).limit(limit)
+		results = []
+		for d in cursor:
+			d["_id"] = str(d.get("_id")) if d.get("_id") else None
+			results.append(d)
+		logger.info(f"Found {len(results)} doctors matching query")
+		return results
+	except Exception as e:
+		logger.error(f"Error in search_doctors: {e}")
+		return []
+
+def get_all_doctors(limit: int = 50) -> list[dict[str, Any]]:
+	"""Get all doctors with optional limit from accounts collection"""
+	collection = get_collection(ACCOUNTS_COLLECTION)
+	try:
+		cursor = collection.find({
+			"role": {"$in": ["Doctor", "Healthcare Prof", "General Practitioner", "Cardiologist", "Pediatrician", "Neurologist", "Dermatologist"]}
+		}).sort("name", ASCENDING).limit(limit)
+		results = []
+		for d in cursor:
+			d["_id"] = str(d.get("_id")) if d.get("_id") else None
+			results.append(d)
+		logger.info(f"Retrieved {len(results)} doctors")
+		return results
+	except Exception as e:
+		logger.error(f"Error getting all doctors: {e}")
+		return []

src/data/patient/__init__.py

@@ -0,0 +1,18 @@
+# data/patient/__init__.py
+"""
+Patient management operations for MongoDB.
+"""
+
+from .operations import (
+    get_patient_by_id,
+    create_patient,
+    update_patient_profile,
+    search_patients,
+)
+
+__all__ = [
+    'get_patient_by_id',
+    'create_patient',
+    'update_patient_profile',
+    'search_patients',
+]

src/data/patient/operations.py

@@ -0,0 +1,101 @@
+# data/patient/operations.py
+"""
+Patient management operations for MongoDB.
+"""
+
+import re
+from datetime import datetime, timezone
+from typing import Any
+
+from pymongo import ASCENDING
+
+from ..connection import get_collection, PATIENTS_COLLECTION
+from src.utils.logger import get_logger
+
+logger = get_logger("PATIENT_OPS")
+
+
+def _generate_patient_id() -> str:
+    """Generate zero-padded 8-digit ID"""
+    import random
+    return f"{random.randint(0, 99999999):08d}"
+
+
+def get_patient_by_id(patient_id: str) -> dict[str, Any] | None:
+    collection = get_collection(PATIENTS_COLLECTION)
+    return collection.find_one({"patient_id": patient_id})
+
+
+def create_patient(
+    *,
+    name: str,
+    age: int,
+    sex: str,
+    address: str | None = None,
+    phone: str | None = None,
+    email: str | None = None,
+    medications: list[str] | None = None,
+    past_assessment_summary: str | None = None,
+    assigned_doctor_id: str | None = None
+) -> dict[str, Any]:
+    collection = get_collection(PATIENTS_COLLECTION)
+    now = datetime.now(timezone.utc)
+    # Ensure unique 8-digit id
+    for _ in range(10):
+        pid = _generate_patient_id()
+        if not collection.find_one({"patient_id": pid}):
+            break
+    else:
+        raise RuntimeError("Failed to generate unique patient ID")
+    doc = {
+        "patient_id": pid,
+        "name": name,
+        "age": age,
+        "sex": sex,
+        "address": address,
+        "phone": phone,
+        "email": email,
+        "medications": medications or [],
+        "past_assessment_summary": past_assessment_summary or "",
+        "assigned_doctor_id": assigned_doctor_id,
+        "created_at": now,
+        "updated_at": now
+    }
+    collection.insert_one(doc)
+    return doc
+
+
+def update_patient_profile(patient_id: str, updates: dict[str, Any]) -> int:
+    collection = get_collection(PATIENTS_COLLECTION)
+    updates["updated_at"] = datetime.now(timezone.utc)
+    result = collection.update_one({"patient_id": patient_id}, {"$set": updates})
+    return result.modified_count
+
+
+def search_patients(query: str, limit: int = 10) -> list[dict[str, Any]]:
+    """Search patients by name (case-insensitive starts-with/contains) or partial patient_id."""
+    collection = get_collection(PATIENTS_COLLECTION)
+    if not query:
+        return []
+    
+    logger.info(f"Searching patients with query: '{query}', limit: {limit}")
+    
+    # Build a regex for name search and patient_id partial match
+    pattern = re.compile(re.escape(query), re.IGNORECASE)
+    
+    try:
+        cursor = collection.find({
+            "$or": [
+                {"name": {"$regex": pattern}},
+                {"patient_id": {"$regex": pattern}}
+            ]
+        }).sort("name", ASCENDING).limit(limit)
+        results = []
+        for p in cursor:
+            p["_id"] = str(p.get("_id")) if p.get("_id") else None
+            results.append(p)
+        logger.info(f"Found {len(results)} patients matching query")
+        return results
+    except Exception as e:
+        logger.error(f"Error in search_patients: {e}")
+        return []

src/data/session/__init__.py

@@ -0,0 +1,24 @@
+# data/session/__init__.py
+"""
+Session management operations for MongoDB.
+"""
+
+from .operations import (
+    create_chat_session,
+    get_user_sessions,
+    ensure_session,
+    list_patient_sessions,
+    delete_session,
+    delete_session_messages,
+    delete_old_sessions,
+)
+
+__all__ = [
+    'create_chat_session',
+    'get_user_sessions',
+    'ensure_session',
+    'list_patient_sessions',
+    'delete_session',
+    'delete_session_messages',
+    'delete_old_sessions',
+]

src/data/session/operations.py

@@ -0,0 +1,126 @@
+# data/session/operations.py
+"""
+Session management operations for MongoDB.
+"""
+
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+from bson import ObjectId
+from pymongo import ASCENDING, DESCENDING
+
+from ..connection import get_collection, CHAT_SESSIONS_COLLECTION, CHAT_MESSAGES_COLLECTION
+from src.utils.logger import get_logger
+
+logger = get_logger("SESSION_OPS")
+
+
+def create_chat_session(
+    session_data: dict[str, Any],
+    /,
+    *,
+    collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> str:
+    """Create a new chat session"""
+    collection = get_collection(collection_name)
+    now = datetime.now(timezone.utc)
+    session_data["created_at"] = now
+    session_data["updated_at"] = now
+    if "_id" not in session_data:
+        session_data["_id"] = str(ObjectId())
+    result = collection.insert_one(session_data)
+    return str(result.inserted_id)
+
+
+def get_user_sessions(
+    user_id: str,
+    /,
+    limit: int = 20,
+    *,
+    collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> list[dict[str, Any]]:
+    """Get chat sessions for a specific user"""
+    collection = get_collection(collection_name)
+    return list(collection.find(
+        {"user_id": user_id}
+    ).sort("updated_at", DESCENDING).limit(limit))
+
+
+def ensure_session(
+    *,
+    session_id: str,
+    patient_id: str,
+    doctor_id: str,
+    title: str,
+    last_activity: datetime | None = None,
+    collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> None:
+    collection = get_collection(collection_name)
+    now = datetime.now(timezone.utc)
+    collection.update_one(
+        {"session_id": session_id},
+        {"$set": {
+            "session_id": session_id,
+            "patient_id": patient_id,
+            "doctor_id": doctor_id,
+            "title": title,
+            "last_activity": (last_activity or now),
+            "updated_at": now
+        }, "$setOnInsert": {"created_at": now}},
+        upsert=True
+    )
+
+
+def list_patient_sessions(
+    patient_id: str,
+    /,
+    *,
+    collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> list[dict[str, Any]]:
+    collection = get_collection(collection_name)
+    sessions = list(collection.find({"patient_id": patient_id}).sort("last_activity", DESCENDING))
+    # Convert ObjectId to string for JSON serialization
+    for session in sessions:
+        if "_id" in session:
+            session["_id"] = str(session["_id"])
+    return sessions
+
+
+def delete_session(
+    session_id: str,
+    /,
+    *,
+    collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> bool:
+    """Delete a chat session from MongoDB"""
+    collection = get_collection(collection_name)
+    result = collection.delete_one({"session_id": session_id})
+    return result.deleted_count > 0
+
+
+def delete_session_messages(
+    session_id: str,
+    /,
+    *,
+    collection_name: str = CHAT_MESSAGES_COLLECTION
+) -> int:
+    """Delete all messages for a session from MongoDB"""
+    collection = get_collection(collection_name)
+    result = collection.delete_many({"session_id": session_id})
+    return result.deleted_count
+
+
+def delete_old_sessions(
+    days: int = 30,
+    *,
+    collection_name: str = CHAT_SESSIONS_COLLECTION
+) -> int:
+    """Delete chat sessions older than specified days"""
+    collection = get_collection(collection_name)
+    cutoff = datetime.now(timezone.utc) - timedelta(days=days)
+    result = collection.delete_many({
+        "updated_at": {"$lt": cutoff}
+    })
+    if result.deleted_count > 0:
+        logger.info(f"Deleted {result.deleted_count} old sessions (>{days} days)")
+    return result.deleted_count

src/data/user/__init__.py

@@ -0,0 +1,24 @@
+# data/user/__init__.py
+"""
+User management operations for MongoDB.
+"""
+
+from .operations import (
+    create_account,
+    update_account,
+    get_account_frame,
+    create_doctor,
+    get_doctor_by_name,
+    search_doctors,
+    get_all_doctors,
+)
+
+__all__ = [
+    'create_account',
+    'update_account',
+    'get_account_frame',
+    'create_doctor',
+    'get_doctor_by_name',
+    'search_doctors',
+    'get_all_doctors',
+]

src/data/user/operations.py

@@ -0,0 +1,146 @@
+# data/user/operations.py
+"""
+User management operations for MongoDB.
+"""
+
+from datetime import datetime, timezone
+from typing import Any
+
+import re
+from pandas import DataFrame
+from pymongo import ASCENDING
+from pymongo.errors import DuplicateKeyError
+
+from ..connection import get_collection, ACCOUNTS_COLLECTION
+from src.utils.logger import get_logger
+
+logger = get_logger("USER_OPS")
+
+
+def get_account_frame(
+    *,
+    collection_name: str = ACCOUNTS_COLLECTION
+) -> DataFrame:
+    """Get accounts as a pandas DataFrame"""
+    return DataFrame(get_collection(collection_name).find())
+
+
+def create_account(
+    user_data: dict[str, Any],
+    /,
+    *,
+    collection_name: str = ACCOUNTS_COLLECTION
+) -> str:
+    """Create a new user account"""
+    collection = get_collection(collection_name)
+    now = datetime.now(timezone.utc)
+    user_data["created_at"] = now
+    user_data["updated_at"] = now
+    try:
+        result = collection.insert_one(user_data)
+        logger.info(f"Created new account: {result.inserted_id}")
+        return str(result.inserted_id)
+    except DuplicateKeyError as e:
+        logger.error(f"Failed to create account - duplicate key: {str(e)}")
+        raise DuplicateKeyError(f"Account already exists: {e}") from e
+
+
+def update_account(
+    user_id: str,
+    updates: dict[str, Any],
+    /,
+    *,
+    collection_name: str = ACCOUNTS_COLLECTION
+) -> bool:
+    """Update an existing user account"""
+    collection = get_collection(collection_name)
+    updates["updated_at"] = datetime.now(timezone.utc)
+    result = collection.update_one(
+        {"_id": user_id},
+        {"$set": updates}
+    )
+    return result.modified_count > 0
+
+
+def create_doctor(
+    *,
+    name: str,
+    role: str | None = None,
+    specialty: str | None = None,
+    medical_roles: list[str] | None = None
+) -> str:
+    """Create a new doctor profile"""
+    collection = get_collection(ACCOUNTS_COLLECTION)
+    now = datetime.now(timezone.utc)
+    doctor_doc = {
+        "name": name,
+        "role": role,
+        "specialty": specialty,
+        "medical_roles": medical_roles or [],
+        "created_at": now,
+        "updated_at": now
+    }
+    try:
+        result = collection.insert_one(doctor_doc)
+        logger.info(f"Created new doctor: {name} with id {result.inserted_id}")
+        return str(result.inserted_id)
+    except Exception as e:
+        logger.error(f"Error creating doctor: {e}")
+        raise e
+
+
+def get_doctor_by_name(name: str) -> dict[str, Any] | None:
+    """Get doctor by name from accounts collection"""
+    collection = get_collection(ACCOUNTS_COLLECTION)
+    doctor = collection.find_one({
+        "name": name,
+        "role": {"$in": ["Doctor", "Healthcare Prof", "General Practitioner", "Cardiologist", "Pediatrician", "Neurologist", "Dermatologist"]}
+    })
+    if doctor:
+        doctor["_id"] = str(doctor.get("_id")) if doctor.get("_id") else None
+    return doctor
+
+
+def search_doctors(query: str, limit: int = 10) -> list[dict[str, Any]]:
+    """Search doctors by name (case-insensitive contains) from accounts collection"""
+    collection = get_collection(ACCOUNTS_COLLECTION)
+    if not query:
+        return []
+    
+    logger.info(f"Searching doctors with query: '{query}', limit: {limit}")
+    
+    # Build a regex for name search
+    pattern = re.compile(re.escape(query), re.IGNORECASE)
+    
+    try:
+        cursor = collection.find({
+            "name": {"$regex": pattern},
+            "role": {"$in": ["Doctor", "Healthcare Prof", "General Practitioner", "Cardiologist", "Pediatrician", "Neurologist", "Dermatologist"]}
+        }).sort("name", ASCENDING).limit(limit)
+        results = []
+        for d in cursor:
+            d["_id"] = str(d.get("_id")) if d.get("_id") else None
+            results.append(d)
+        logger.info(f"Found {len(results)} doctors matching query")
+        return results
+    except Exception as e:
+        logger.error(f"Error in search_doctors: {e}")
+        return []
+
+
+def get_all_doctors(limit: int = 50) -> list[dict[str, Any]]:
+    """Get all doctors with optional limit from accounts collection"""
+    collection = get_collection(ACCOUNTS_COLLECTION)
+    try:
+        cursor = collection.find({
+            "role": {"$in": ["Doctor", "Healthcare Prof", "General Practitioner", "Cardiologist", "Pediatrician", "Neurologist", "Dermatologist"]}
+        }).sort("name", ASCENDING).limit(limit)
+        results = []
+        for d in cursor:
+            d["_id"] = str(d.get("_id")) if d.get("_id") else None
+            results.append(d)
+        logger.info(f"Retrieved {len(results)} doctors")
+        return results
+    except Exception as e:
+        logger.error(f"Error getting all doctors: {e}")
+        return []

src/data/utils.py

@@ -0,0 +1,48 @@
+# data/utils.py
+"""
+Utility functions for MongoDB operations.
+"""
+
+from datetime import datetime, timezone
+from typing import Any
+
+from pymongo import ASCENDING
+
+from .connection import get_collection, get_database
+from src.utils.logger import get_logger
+
+logger = get_logger("MONGO_UTILS")
+
+
+def create_index(
+    collection_name: str,
+    field_name: str,
+    /,
+    unique: bool = False
+) -> None:
+    """Create an index on a collection"""
+    collection = get_collection(collection_name)
+    collection.create_index([(field_name, ASCENDING)], unique=unique)
+
+
+def backup_collection(collection_name: str) -> str:
+    """Create a backup of a collection"""
+    collection = get_collection(collection_name)
+    backup_name = f"{collection_name}_backup_{datetime.now(timezone.utc).strftime('%Y%m%d')}"
+    db = get_database()
+
+    # Drop existing backup if it exists
+    if backup_name in db.list_collection_names():
+        logger.info(f"Removing existing backup: {backup_name}")
+        db.drop_collection(backup_name)
+
+    db.create_collection(backup_name)
+    backup = db[backup_name]
+
+    doc_count = 0
+    for doc in collection.find():
+        backup.insert_one(doc)
+        doc_count += 1
+
+    logger.info(f"Created backup {backup_name} with {doc_count} documents")
+    return backup_name

src/models/chat.py

@@ -4,6 +4,8 @@ from pydantic import BaseModel
 
 class ChatRequest(BaseModel):
 	user_id: str
+	patient_id: str
+	doctor_id: str
 	session_id: str
 	message: str
 	user_role: str | None = "Medical Professional"
@@ -18,6 +20,8 @@ class ChatResponse(BaseModel):
 
 class SessionRequest(BaseModel):
 	user_id: str
+	patient_id: str
+	doctor_id: str
 	title: str | None = "New Chat"
 
 class SummariseRequest(BaseModel):

src/models/user.py

@@ -1,9 +1,38 @@
 # model/user.py
-
 from pydantic import BaseModel
+from typing import Optional, List
 
 class UserProfileRequest(BaseModel):
 	user_id: str
 	name: str
 	role: str
-	specialty: str | None = ""
+	specialty: Optional[str] = None
+	medical_roles: Optional[List[str]] = None
+
+class PatientCreateRequest(BaseModel):
+	name: str
+	age: int
+	sex: str
+	address: Optional[str] = None
+	phone: Optional[str] = None
+	email: Optional[str] = None
+	medications: Optional[List[str]] = None
+	past_assessment_summary: Optional[str] = None
+	assigned_doctor_id: Optional[str] = None
+
+class PatientUpdateRequest(BaseModel):
+	name: Optional[str] = None
+	age: Optional[int] = None
+	sex: Optional[str] = None
+	address: Optional[str] = None
+	phone: Optional[str] = None
+	email: Optional[str] = None
+	medications: Optional[List[str]] = None
+	past_assessment_summary: Optional[str] = None
+	assigned_doctor_id: Optional[str] = None
+
+class DoctorCreateRequest(BaseModel):
+	name: str
+	role: Optional[str] = None
+	specialty: Optional[str] = None
+	medical_roles: Optional[List[str]] = None

start.py

@@ -36,10 +36,26 @@ def main():
 	else:
 		print(f"✅ Found {len(gemini_keys)} Gemini API keys")
 
+	# Check for MongoDB environment variables
+	mongo_user = os.getenv("MONGO_USER")
+	user_db = os.getenv("USER_DB")
+	
+	if not mongo_user:
+		print("❌ Error: MONGO_USER environment variable not found!")
+		print("Set MONGO_USER environment variable for database connectivity.")
+		sys.exit(1)
+	
+	if not user_db:
+		print("❌ Error: USER_DB environment variable not found!")
+		print("Set USER_DB environment variable for database connectivity.")
+		sys.exit(1)
+	
+	print("✅ MongoDB environment variables found")
+
 	print("\n📱 Starting Medical AI Assistant...")
-	print("🌐 Web UI will be available at: http://localhost:7860")
-	print("📚 API documentation at: http://localhost:7860/docs")
-	print("🔍 Health check at: http://localhost:7860/health")
+	print("🌐 Web UI will be available at: https://medai-cos30018-medicaldiagnosissystem.hf.space")
+	print("📚 API documentation at: https://medai-cos30018-medicaldiagnosissystem.hf.space/docs")
+	print("🔍 Health check at: https://medai-cos30018-medicaldiagnosissystem.hf.space/health")
 	print("\nPress Ctrl+C to stop the server")
 	print("=" * 50)
 

static/css/emr.css

@@ -0,0 +1,340 @@
+/* EMR Page Styles */
+.emr-container {
+    min-height: 100vh;
+    background-color: var(--bg-primary);
+    color: var(--text-primary);
+}
+
+.emr-header {
+    background-color: var(--bg-secondary);
+    border-bottom: 1px solid var(--border-color);
+    padding: 1rem 0;
+    position: sticky;
+    top: 0;
+    z-index: 100;
+}
+
+.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;
+}
+
+.back-link {
+    display: inline-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);
+}
+
+.back-link:hover {
+    background-color: var(--bg-tertiary);
+}
+
+.emr-header h1 {
+    margin: 0;
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.patient-info-header {
+    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;
+}
+
+.emr-main {
+    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;
+}
+
+.emr-section h2 {
+    margin: 0 0 1.5rem 0;
+    font-size: 1.25rem;
+    font-weight: 600;
+    color: var(--text-primary);
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.emr-section h2 i {
+    color: var(--primary-color);
+}
+
+.emr-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+    gap: 1.5rem;
+}
+
+.emr-field {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.emr-field.full-width {
+    grid-column: 1 / -1;
+}
+
+.emr-field label {
+    font-weight: 500;
+    color: var(--text-primary);
+    font-size: 0.9rem;
+}
+
+.emr-field input,
+.emr-field select,
+.emr-field textarea {
+    padding: 0.75rem;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    background-color: var(--bg-primary);
+    color: var(--text-primary);
+    font-size: 0.9rem;
+    transition: border-color var(--transition-fast);
+}
+
+.emr-field input:focus,
+.emr-field select:focus,
+.emr-field textarea:focus {
+    outline: none;
+    border-color: var(--primary-color);
+    box-shadow: 0 0 0 2px rgba(var(--primary-color-rgb), 0.1);
+}
+
+.emr-field textarea {
+    resize: vertical;
+    min-height: 80px;
+}
+
+/* Medications */
+.medications-container {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.medications-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+    min-height: 40px;
+    padding: 0.5rem;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    background-color: var(--bg-primary);
+}
+
+.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;
+    font-weight: 500;
+}
+
+.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);
+}
+
+.medication-tag .remove-medication:hover {
+    opacity: 1;
+}
+
+.add-medication {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+}
+
+.add-medication input {
+    flex: 1;
+    margin: 0;
+}
+
+.add-medication button {
+    white-space: nowrap;
+}
+
+/* Sessions */
+.sessions-container {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.session-item {
+    background-color: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    padding: 1rem;
+    cursor: pointer;
+    transition: all var(--transition-fast);
+}
+
+.session-item:hover {
+    border-color: var(--primary-color);
+    background-color: var(--bg-tertiary);
+}
+
+.session-title {
+    font-weight: 600;
+    color: var(--text-primary);
+    margin-bottom: 0.5rem;
+}
+
+.session-meta {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+}
+
+.session-date {
+    font-family: monospace;
+}
+
+.session-messages {
+    color: var(--text-secondary);
+}
+
+/* Actions */
+.emr-actions {
+    display: flex;
+    gap: 1rem;
+    flex-wrap: wrap;
+}
+
+.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;
+}
+
+.btn-primary {
+    background-color: var(--primary-color);
+    color: white;
+}
+
+.btn-primary:hover {
+    background-color: var(--primary-color-dark);
+    transform: translateY(-1px);
+}
+
+.btn-secondary {
+    background-color: var(--bg-tertiary);
+    color: var(--text-primary);
+    border: 1px solid var(--border-color);
+}
+
+.btn-secondary:hover {
+    background-color: var(--bg-primary);
+    border-color: var(--primary-color);
+}
+
+/* Loading States */
+.loading {
+    opacity: 0.6;
+    pointer-events: none;
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .emr-header-content {
+        flex-direction: column;
+        align-items: stretch;
+        text-align: center;
+    }
+    
+    .patient-info-header {
+        align-items: center;
+        text-align: center;
+    }
+    
+    .emr-main {
+        padding: 1rem;
+    }
+    
+    .emr-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .emr-actions {
+        flex-direction: column;
+    }
+    
+    .add-medication {
+        flex-direction: column;
+        align-items: stretch;
+    }
+}
+
+/* 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);
+}
+
+[data-theme="dark"] .medications-list {
+    background-color: var(--bg-secondary);
+}
+
+[data-theme="dark"] .session-item {
+    background-color: var(--bg-secondary);
+}

static/css/patient.css

@@ -0,0 +1,22 @@
+body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif; background: #0f172a; color: #e2e8f0; }
+.container { max-width: 900px; margin: 40px auto; padding: 24px; background: #111827; border-radius: 12px; box-shadow: 0 10px 30px rgba(0,0,0,0.4); }
+.back-link { display:inline-flex; align-items:center; gap:8px; color:#93c5fd; text-decoration:none; margin-bottom:12px; }
+.back-link:hover { text-decoration:underline; }
+h1 { margin-bottom: 16px; font-size: 1.6rem; }
+.grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 16px; }
+label { display: grid; gap: 6px; font-size: 0.9rem; }
+input, select, textarea { padding: 10px; border-radius: 8px; border: 1px solid #334155; background: #0b1220; color: #e2e8f0; }
+textarea { min-height: 100px; }
+.actions { display: flex; gap: 10px; justify-content: flex-end; margin-top: 18px; }
+.primary { background: #2563eb; color: #fff; border: none; padding: 10px 14px; border-radius: 8px; cursor: pointer; }
+.secondary { background: transparent; color: #e2e8f0; border: 1px solid #334155; padding: 10px 14px; border-radius: 8px; cursor: pointer; }
+.result { margin-top: 12px; color: #93c5fd; }
+@media (max-width: 720px) { .grid { grid-template-columns: 1fr; } }
+.modal { position: fixed; inset:0; display:none; align-items:center; justify-content:center; background: rgba(0,0,0,0.45); z-index: 3000; }
+.modal.show { display:flex; }
+.modal-content { background:#111827; color:#e2e8f0; width: 520px; max-width: 92vw; border-radius: 12px; overflow:hidden; box-shadow: 0 10px 30px rgba(0,0,0,0.4); }
+.modal-header, .modal-footer { padding: 16px; border-bottom: 1px solid #334155; display:flex; align-items:center; justify-content: space-between; }
+.modal-footer { border-bottom: none; border-top: 1px solid #334155; justify-content: flex-end; gap: 8px; }
+.modal-body { padding: 16px; }
+.modal-close { background: transparent; border: none; color: #94a3b8; font-size: 20px; cursor: pointer; }
+.big-id { font-size: 28px; letter-spacing: 2px; font-weight: 700; color: #93c5fd; margin: 8px 0 4px; }

static/css/styles.css

@@ -80,6 +80,8 @@ body {
     height: 100vh;
     overflow: hidden;
 }
+.app-overlay { position: fixed; inset:0; background: rgba(0,0,0,0.2); display:none; z-index: 1000; }
+.app-overlay.show { display:block; }
 
 /* Sidebar */
 .sidebar {
@@ -89,7 +91,7 @@ body {
     display: flex;
     flex-direction: column;
     transition: transform var(--transition-normal);
-    z-index: 1000;
+    z-index: 1001;
 }
 
 .sidebar-header {
@@ -358,6 +360,19 @@ body {
     background-color: var(--bg-tertiary);
 }
 
+.sidebar-close {
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    font-size: 1.2rem;
+    cursor: pointer;
+    padding: var(--spacing-sm);
+    border-radius: 6px;
+    transition: background-color var(--transition-fast);
+    margin-left: auto;
+}
+.sidebar-close:hover { background-color: var(--bg-tertiary); }
+
 .chat-title {
     flex: 1;
     font-size: 1.25rem;
@@ -742,11 +757,15 @@ body {
         left: 0;
         top: 0;
         height: 100vh;
+        width: 300px;
         transform: translateX(-100%);
+        transition: transform 0.3s ease;
+        z-index: 1001;
     }
 
     .sidebar.show {
         transform: translateX(0);
+        z-index: 1002;
     }
 
     .sidebar-toggle {
@@ -757,6 +776,24 @@ body {
         font-size: 1rem;
     }
 
+    .app-overlay {
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.5);
+        z-index: 999;
+        display: none;
+        opacity: 0;
+        transition: opacity 0.3s ease;
+    }
+
+    .app-overlay.show {
+        display: block;
+        opacity: 1;
+    }
+
     .modal-content {
         width: 95%;
         margin: var(--spacing-md);
@@ -858,3 +895,111 @@ body {
     color: var(--primary-color);
     margin-right: var(--spacing-sm);
 }
+
+.patient-section {
+    padding: var(--spacing-lg);
+    border-bottom: 1px solid var(--border-color);
+}
+
+.patient-header {
+    font-weight: 600;
+    margin-bottom: var(--spacing-sm);
+    color: var(--text-primary);
+}
+
+.patient-input-group {
+    display: flex;
+    gap: var(--spacing-sm);
+    align-items: center;
+}
+.patient-typeahead { position: relative; }
+.patient-suggestions { position:absolute; top: 100%; left:0; right:0; background: var(--bg-primary); border: 1px solid var(--border-color); border-radius: 6px; box-shadow: var(--shadow-lg); z-index: 3500; max-height: 220px; overflow-y: auto; }
+.patient-suggestion { padding: 8px 10px; cursor:pointer; color: var(--text-primary); }
+.patient-suggestion:hover { background: var(--bg-tertiary); }
+
+.patient-input {
+    flex: 1;
+    padding: 8px 10px;
+    border: 1px solid var(--border-color);
+    border-radius: 6px;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+}
+
+.patient-load-btn {
+    padding: 8px 10px;
+    background: var(--primary-color);
+    color: #fff;
+    border: none;
+    border-radius: 6px;
+    cursor: pointer;
+}
+.patient-load-btn:hover {
+    background: var(--primary-hover);
+}
+.patient-create-link { 
+    display:inline-flex; align-items:center; 
+    justify-content:center; padding:8px 10px; 
+    border: 1px solid var(--border-color); 
+    border-radius:6px; color: var(--text-secondary); 
+    text-decoration:none; 
+}
+.patient-create-link:hover { background: var(--bg-tertiary); }
+
+.patient-status {
+    margin-top: var(--spacing-sm);
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+}
+
+.patient-actions {
+    margin-top: var(--spacing-sm);
+    text-align: center;
+}
+
+.emr-link {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.5rem 1rem;
+    background-color: var(--primary-color);
+    color: white;
+    text-decoration: none;
+    border-radius: 6px;
+    font-size: 0.8rem;
+    font-weight: 500;
+    transition: all var(--transition-fast);
+}
+
+.emr-link:hover {
+    background-color: var(--primary-color-dark);
+    transform: translateY(-1px);
+    color: white;
+}
+
+/* Sidebar mobile behavior */
+@media (max-width: 1024px) {
+    .sidebar {
+        position: fixed;
+        top: 0;
+        bottom: 0;
+        left: 0;
+        transform: translateX(-100%);
+        width: 85vw;
+    }
+    .sidebar.show {
+        transform: translateX(0);
+    }
+    .main-content {
+        position: relative;
+        z-index: 1;
+    }
+    .sidebar-toggle {
+        display: inline-flex;
+    }
+}
+
+/* Loading overlay default hidden */
+.loading-overlay { display: none; align-items: center; justify-content: center; position: fixed; inset: 0; background: rgba(0,0,0,0.35); z-index: 3000; pointer-events: none; }
+.loading-overlay.show { display: flex; pointer-events: all; }
+.loading-spinner { display: grid; gap: 8px; color: #fff; text-align: center; }

static/emr.html

@@ -0,0 +1,127 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Patient EMR - Medical AI Assistant</title>
+    <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">
+</head>
+<body>
+    <div class="emr-container">
+        <!-- Header -->
+        <header 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>
+            </div>
+        </header>
+
+        <!-- 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">
+                    <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 class="emr-field">
+                        <label>Sex</label>
+                        <select id="patientSexInput">
+                            <option value="">Select sex</option>
+                            <option value="Male">Male</option>
+                            <option value="Female">Female</option>
+                            <option value="Other">Other</option>
+                        </select>
+                    </div>
+                    <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 full-width">
+                        <label>Address</label>
+                        <textarea id="patientAddressInput" placeholder="Enter full address" rows="3"></textarea>
+                    </div>
+                </div>
+            </section>
+
+            <!-- Medical Information -->
+            <section class="emr-section">
+                <h2><i class="fas fa-pills"></i> Medical Information</h2>
+                <div class="emr-grid">
+                    <div class="emr-field full-width">
+                        <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 full-width">
+                        <label>Past Assessment Summary</label>
+                        <textarea id="pastAssessmentInput" placeholder="Enter past assessment summary" rows="4"></textarea>
+                    </div>
+                </div>
+            </section>
+
+            <!-- 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 -->
+                </div>
+            </section>
+
+            <!-- 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>
+                </div>
+            </section>
+        </main>
+    </div>
+
+    <!-- Loading Overlay -->
+    <div class="loading-overlay" id="loadingOverlay">
+        <div class="loading-spinner">
+            <i class="fas fa-spinner fa-spin"></i>
+            <div>Loading...</div>
+        </div>
+    </div>
+
+    <script src="/static/js/emr.js"></script>
+</body>
+</html>

static/index.html

@@ -10,6 +10,7 @@
 </head>
 <body>
     <div class="app-container">
+        <div class="app-overlay" id="appOverlay"></div>
         <!-- Sidebar -->
         <div class="sidebar" id="sidebar">
             <div class="sidebar-header">
@@ -26,7 +27,7 @@
                     </div>
                     <div class="user-info">
                         <div class="user-name" id="userName">Anonymous</div>
-                        <div class="user-status">Medical Professional</div>
+                        <div class="user-status" id="userStatus">Medical Professional</div>
                     </div>
                     <button class="user-menu-btn" id="userMenuBtn">
                         <i class="fas fa-ellipsis-v"></i>
@@ -34,6 +35,27 @@
                 </div>
             </div>
 
+            <!-- Patient Login Section -->
+            <div class="patient-section">
+                <div class="patient-header">Patient</div>
+                <div class="patient-input-group patient-typeahead">
+                    <input type="text" id="patientIdInput" class="patient-input" placeholder="Search patient by name or ID">
+                    <div id="patientSuggestions" class="patient-suggestions" style="display:none;"></div>
+                    <button class="patient-load-btn" id="loadPatientBtn" title="Load Patient">
+                        <i class="fas fa-arrow-right"></i>
+                    </button>
+                    <a class="patient-create-link" id="createPatientLink" href="/static/patient.html" title="Create new patient">
+                        <i class="fas fa-user-plus"></i>
+                    </a>
+                </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">
+                        <i class="fas fa-file-medical"></i> EMR
+                    </a>
+                </div>
+            </div>
+
             <div class="chat-sessions" id="chatSessions">
                 <!-- Chat sessions will be populated here -->
             </div>
@@ -122,22 +144,31 @@
     <div class="modal" id="userModal">
         <div class="modal-content">
             <div class="modal-header">
-                <h3>User Profile</h3>
+                <h3>Doctor Profile</h3>
                 <button class="modal-close" id="userModalClose">&times;</button>
             </div>
             <div class="modal-body">
                 <div class="form-group">
-                    <label for="profileName">Name:</label>
-                    <input type="text" id="profileName" placeholder="Enter your name">
+                    <label for="profileNameSelect">Name:</label>
+                    <select id="profileNameSelect"></select>
+                </div>
+                <div class="form-group" id="newDoctorSection" style="display:none;">
+                    <label for="newDoctorName">Doctor name</label>
+                    <input type="text" id="newDoctorName" placeholder="Enter doctor name">
+                    <div style="display:flex; gap:8px; margin-top:8px;">
+                        <button type="button" class="btn btn-secondary" id="cancelNewDoctor">Cancel</button>
+                        <button type="button" class="btn btn-primary" id="confirmNewDoctor">Confirm</button>
+                    </div>
                 </div>
                 <div class="form-group">
                     <label for="profileRole">Medical Role:</label>
                     <select id="profileRole">
-                        <option value="Physician">Physician</option>
+                        <option value="Doctor">Doctor</option>
+                        <option value="Healthcare Prof">Healthcare Prof</option>
                         <option value="Nurse">Nurse</option>
+                        <option value="Caregiver">Caregiver</option>
+                        <option value="Physician">Physician</option>
                         <option value="Medical Student">Medical Student</option>
-                        <option value="Healthcare Professional">Healthcare Professional</option>
-                        <option value="Patient">Patient</option>
                         <option value="Other">Other</option>
                     </select>
                 </div>
@@ -187,10 +218,7 @@
                     </label>
                 </div>
             </div>
-            <div class="modal-footer">
-                <button class="btn btn-secondary" id="settingsModalCancel">Cancel</button>
-                <button class="btn btn-primary" id="settingsModalSave">Save</button>
-            </div>
+            <div class="modal-footer"></div>
         </div>
     </div>
 
@@ -214,6 +242,27 @@
         </div>
     </div>
 
+    <!-- Patient Modal -->
+    <div class="modal" id="patientModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3>Patient Profile</h3>
+                <button class="modal-close" id="patientModalClose">&times;</button>
+            </div>
+            <div class="modal-body">
+                <div class="patient-summary" id="patientSummary"></div>
+                <div class="patient-details">
+                    <div><strong>Medications:</strong> <span id="patientMedications">-</span></div>
+                    <div><strong>Past Assessment:</strong> <span id="patientAssessment">-</span></div>
+                </div>
+            </div>
+            <div class="modal-footer">
+                <button id="patientLogoutBtn" class="btn-danger">Log out patient</button>
+                <a id="patientCreateBtn" class="btn-primary" href="/static/patient.html">Create new patient</a>
+            </div>
+        </div>
+    </div>
+
     <!-- Loading overlay -->
     <div class="loading-overlay" id="loadingOverlay">
         <div class="loading-spinner">
@@ -222,6 +271,9 @@
         </div>
     </div>
 
-    <script src="/static/js/app.js"></script>
+    <!-- Sidebar overlay for outside-click close -->
+    <div id="sidebarOverlay" style="display:none;position:fixed;inset:0;background:rgba(0,0,0,0.35);z-index:900;"></div>
+
+    <script type="module" src="/static/js/app.js"></script>
 </body>
 </html>

static/js/chat/messaging.js

@@ -0,0 +1,162 @@
+// chat/messaging.js
+// Send, API call, add/display message, summariseTitle, format content/time
+
+export function attachMessagingUI(app) {
+	app.sendMessage = async function () {
+		const input = document.getElementById('chatInput');
+		const message = input.value.trim();
+		if (!message || app.isLoading) return;
+		if (!app.currentPatientId) {
+			const status = document.getElementById('patientStatus');
+			if (status) { status.textContent = 'Select a patient before chatting.'; status.style.color = 'var(--warning-color)'; }
+			return;
+		}
+		input.value = '';
+		app.autoResizeTextarea(input);
+		app.addMessage('user', message);
+		app.showLoading(true);
+		try {
+			const response = await app.callMedicalAPI(message);
+			app.addMessage('assistant', response);
+			app.updateCurrentSession();
+		} catch (error) {
+			console.error('Error sending message:', error);
+			let errorMessage = 'I apologize, but I encountered an error processing your request.';
+			if (error.message.includes('500')) errorMessage = 'The server encountered an internal error. Please try again in a moment.';
+			else if (error.message.includes('404')) errorMessage = 'The requested service was not found. Please check your connection.';
+			else if (error.message.includes('fetch')) errorMessage = 'Unable to connect to the server. Please check your internet connection.';
+			app.addMessage('assistant', errorMessage);
+		} finally {
+			app.showLoading(false);
+		}
+	};
+
+	app.callMedicalAPI = async function (message) {
+		try {
+			const response = await fetch('/chat', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({
+					user_id: app.currentUser.id,
+					patient_id: app.currentPatientId,
+					doctor_id: app.currentUser.id,
+					session_id: app.currentSession?.id || 'default',
+					message: message,
+					user_role: app.currentUser.role,
+					user_specialty: app.currentUser.specialty,
+					title: app.currentSession?.title || 'New Chat'
+				})
+			});
+			if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+			const data = await response.json();
+			return data.response || 'I apologize, but I received an empty response. Please try again.';
+		} catch (error) {
+			console.error('API call failed:', error);
+			console.error('Error details:', {
+				message: error.message,
+				stack: error.stack,
+				user: app.currentUser,
+				session: app.currentSession,
+				patientId: app.currentPatientId
+			});
+			if (error.name === 'TypeError' && error.message.includes('fetch')) return app.generateMockResponse(message);
+			throw error;
+		}
+	};
+
+	app.generateMockResponse = function (message) {
+		const responses = [
+			"Based on your question about medical topics, I can provide general information. However, please remember that this is for educational purposes only and should not replace professional medical advice.",
+			"That's an interesting medical question. While I can offer some general insights, it's important to consult with healthcare professionals for personalized medical advice.",
+			"I understand your medical inquiry. For accurate diagnosis and treatment recommendations, please consult with qualified healthcare providers who can assess your specific situation.",
+			"Thank you for your medical question. I can provide educational information, but medical decisions should always be made in consultation with healthcare professionals.",
+			"I appreciate your interest in medical topics. Remember that medical information found online should be discussed with healthcare providers for proper evaluation."
+		];
+		return responses[Math.floor(Math.random() * responses.length)];
+	};
+
+	app.addMessage = function (role, content) {
+		if (!app.currentSession) app.startNewChat();
+		const message = { id: app.generateId(), role, content, timestamp: new Date().toISOString() };
+		app.currentSession.messages.push(message);
+		app.displayMessage(message);
+		if (role === 'user' && app.currentSession.messages.length === 2) app.summariseAndSetTitle(content);
+	};
+
+	app.summariseAndSetTitle = async function (text) {
+		try {
+			const resp = await fetch('/summarise', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text, max_words: 5 }) });
+			if (resp.ok) {
+				const data = await resp.json();
+				const title = (data.title || 'New Chat').trim();
+				app.currentSession.title = title;
+				app.updateCurrentSession();
+				app.updateChatTitle();
+				app.loadChatSessions();
+			} else {
+				const fallback = text.length > 50 ? text.substring(0, 50) + '...' : text;
+				app.currentSession.title = fallback;
+				app.updateCurrentSession();
+				app.updateChatTitle();
+				app.loadChatSessions();
+			}
+		} catch (e) {
+			const fallback = text.length > 50 ? text.substring(0, 50) + '...' : text;
+			app.currentSession.title = fallback;
+			app.updateCurrentSession();
+			app.updateChatTitle();
+			app.loadChatSessions();
+		}
+	};
+
+	app.displayMessage = function (message) {
+		const chatMessages = document.getElementById('chatMessages');
+		const messageElement = document.createElement('div');
+		messageElement.className = `message ${message.role}-message fade-in`;
+		messageElement.id = `message-${message.id}`;
+		const avatar = message.role === 'user' ? '<i class="fas fa-user"></i>' : '<i class="fas fa-robot"></i>';
+		const time = app.formatTime(message.timestamp);
+		messageElement.innerHTML = `
+			<div class="message-avatar">${avatar}</div>
+			<div class="message-content">
+				<div class="message-text">${app.formatMessageContent(message.content)}</div>
+				<div class="message-time">${time}</div>
+			</div>`;
+		chatMessages.appendChild(messageElement);
+		chatMessages.scrollTop = chatMessages.scrollHeight;
+		if (app.currentSession) app.currentSession.lastActivity = new Date().toISOString();
+	};
+
+	app.formatMessageContent = function (content) {
+		return content
+			// Handle headers (1-6 # symbols)
+			.replace(/^#{1,6}\s+(.+)$/gm, (match, text, offset, string) => {
+				const level = match.match(/^#+/)[0].length;
+				return `<h${level}>${text}</h${level}>`;
+			})
+			// Handle bold text
+			.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+			// Handle italic text
+			.replace(/\*(.*?)\*/g, '<em>$1</em>')
+			// Handle line breaks
+			.replace(/\n/g, '<br>')
+			// Handle emojis with colors
+			.replace(/🔍/g, '<span style="color: var(--primary-color);">🔍</span>')
+			.replace(/📋/g, '<span style="color: var(--secondary-color);">📋</span>')
+			.replace(/💊/g, '<span style="color: var(--accent-color);">💊</span>')
+			.replace(/📚/g, '<span style="color: var(--success-color);">📚</span>')
+			.replace(/⚠️/g, '<span style="color: var(--warning-color);">⚠️</span>');
+	};
+
+	app.formatTime = function (timestamp) {
+		const date = new Date(timestamp);
+		const now = new Date();
+		const diff = now - date;
+		if (diff < 60000) return 'Just now';
+		if (diff < 3600000) { const minutes = Math.floor(diff / 60000); return `${minutes} minute${minutes > 1 ? 's' : ''} ago`; }
+		if (diff < 86400000) { const hours = Math.floor(diff / 3600000); return `${hours} hour${hours > 1 ? 's' : ''} ago`; }
+		return date.toLocaleDateString();
+	};
+}
+
+

static/js/chat/sessions.js

@@ -0,0 +1,164 @@
+// chat/sessions.js
+// Session sidebar rendering, context menu, rename/delete, local storage helpers
+
+export function attachSessionsUI(app) {
+	app.getChatSessions = function () {
+		const sessions = localStorage.getItem(`chatSessions_${app.currentUser.id}`);
+		return sessions ? JSON.parse(sessions) : [];
+	};
+
+	app.saveCurrentSession = function () {
+		if (!app.currentSession) return;
+		if (app.currentSession.source === 'backend') return; // do not persist backend sessions locally here
+		const sessions = app.getChatSessions();
+		const existingIndex = sessions.findIndex(s => s.id === app.currentSession.id);
+		if (existingIndex >= 0) sessions[existingIndex] = { ...app.currentSession };
+		else sessions.unshift(app.currentSession);
+		localStorage.setItem(`chatSessions_${app.currentUser.id}`, JSON.stringify(sessions));
+	};
+
+	app.updateCurrentSession = function () {
+		if (app.currentSession) {
+			app.currentSession.lastActivity = new Date().toISOString();
+			app.saveCurrentSession();
+		}
+	};
+
+	app.updateChatTitle = function () {
+		const titleElement = document.getElementById('chatTitle');
+		if (app.currentSession) titleElement.textContent = app.currentSession.title; else titleElement.textContent = 'Medical AI Assistant';
+	};
+
+	app.loadChatSession = function (sessionId) {
+		const sessions = app.getChatSessions();
+		const session = sessions.find(s => s.id === sessionId);
+		if (!session) return;
+		app.currentSession = session;
+		app.clearChatMessages();
+		session.messages.forEach(message => app.displayMessage(message));
+		app.updateChatTitle();
+		app.loadChatSessions();
+	};
+
+	app.deleteChatSession = function (sessionId) {
+		const sessions = app.getChatSessions();
+		const index = sessions.findIndex(s => s.id === sessionId);
+		if (index === -1) return;
+		const confirmDelete = confirm('Delete this chat session? This cannot be undone.');
+		if (!confirmDelete) return;
+		sessions.splice(index, 1);
+		localStorage.setItem(`chatSessions_${app.currentUser.id}`, JSON.stringify(sessions));
+		if (app.currentSession && app.currentSession.id === sessionId) {
+			if (sessions.length > 0) {
+				app.currentSession = sessions[0];
+				app.clearChatMessages();
+				app.currentSession.messages.forEach(m => app.displayMessage(m));
+				app.updateChatTitle();
+			} else {
+				app.currentSession = null;
+				app.clearChatMessages();
+				app.updateChatTitle();
+			}
+		}
+		app.loadChatSessions();
+	};
+
+	app.renameChatSession = function (sessionId, newTitle) {
+		const sessions = app.getChatSessions();
+		const idx = sessions.findIndex(s => s.id === sessionId);
+		if (idx === -1) return;
+		sessions[idx] = { ...sessions[idx], title: newTitle };
+		localStorage.setItem(`chatSessions_${app.currentUser.id}`, JSON.stringify(sessions));
+		if (app.currentSession && app.currentSession.id === sessionId) {
+			app.currentSession.title = newTitle;
+			app.updateChatTitle();
+		}
+		app.loadChatSessions();
+	};
+
+	app.showSessionMenu = function (anchorEl, sessionId) {
+		// Remove existing popover
+		document.querySelectorAll('.chat-session-menu-popover').forEach(p => p.remove());
+		const rect = anchorEl.getBoundingClientRect();
+		const pop = document.createElement('div');
+		pop.className = 'chat-session-menu-popover show';
+		pop.innerHTML = `
+			<div class="chat-session-menu-item" data-action="edit" data-session-id="${sessionId}"><i class="fas fa-pen"></i> Edit Name</div>
+			<div class="chat-session-menu-item" data-action="delete" data-session-id="${sessionId}"><i class="fas fa-trash"></i> Delete</div>
+		`;
+		document.body.appendChild(pop);
+		pop.style.top = `${rect.bottom + window.scrollY + 6}px`;
+		pop.style.left = `${rect.right + window.scrollX - pop.offsetWidth}px`;
+		const onDocClick = (ev) => {
+			if (!pop.contains(ev.target) && ev.target !== anchorEl) {
+				pop.remove();
+				document.removeEventListener('click', onDocClick);
+			}
+		};
+		setTimeout(() => document.addEventListener('click', onDocClick), 0);
+		pop.querySelectorAll('.chat-session-menu-item').forEach(item => {
+			item.addEventListener('click', (e) => {
+				const action = item.getAttribute('data-action');
+				const id = item.getAttribute('data-session-id');
+				if (action === 'delete') app.deleteChatSession(id);
+				else if (action === 'edit') {
+					app._pendingEditSessionId = id;
+					const sessions = app.getChatSessions();
+					const s = sessions.find(x => x.id === id);
+					const input = document.getElementById('editSessionTitleInput');
+					if (input) input.value = s ? s.title : '';
+					app.showModal('editTitleModal');
+				}
+				pop.remove();
+			});
+		});
+	};
+
+	app.loadChatSessions = function () {
+		const sessionsContainer = document.getElementById('chatSessions');
+		sessionsContainer.innerHTML = '';
+		const sessions = (app.backendSessions && app.backendSessions.length > 0) ? app.backendSessions : app.getChatSessions();
+		if (sessions.length === 0) {
+			sessionsContainer.innerHTML = '<div class="no-sessions">No chat sessions yet</div>';
+			return;
+		}
+		sessions.forEach(session => {
+			const sessionElement = document.createElement('div');
+			sessionElement.className = `chat-session ${session.id === app.currentSession?.id ? 'active' : ''}`;
+			sessionElement.addEventListener('click', async () => {
+				if (session.source === 'backend') {
+					app.currentSession = { ...session };
+					await app.hydrateMessagesForSession(session.id);
+				} else {
+					app.loadChatSession(session.id);
+				}
+			});
+			const time = app.formatTime(session.lastActivity);
+			sessionElement.innerHTML = `
+				<div class="chat-session-row">
+					<div class="chat-session-meta">
+						<div class="chat-session-title">${session.title}</div>
+						<div class="chat-session-time">${time}</div>
+					</div>
+					<div class="chat-session-actions">
+						<button class="chat-session-menu" title="Options" aria-label="Options" data-session-id="${session.id}">
+							<i class="fas fa-ellipsis-vertical"></i>
+						</button>
+					</div>
+				</div>
+			`;
+			sessionsContainer.appendChild(sessionElement);
+			const menuBtn = sessionElement.querySelector('.chat-session-menu');
+			if (session.source !== 'backend') {
+				menuBtn.addEventListener('click', (e) => {
+					e.stopPropagation();
+					app.showSessionMenu(e.currentTarget, session.id);
+				});
+			} else {
+				menuBtn.disabled = true;
+				menuBtn.style.opacity = 0.5;
+				menuBtn.title = 'Options available for local sessions only';
+			}
+		});
+	};
+}

static/js/emr.js

@@ -0,0 +1,288 @@
+// EMR Page JavaScript
+class PatientEMR {
+    constructor() {
+        this.patientId = null;
+        this.patientData = null;
+        this.medications = [];
+        this.sessions = [];
+        
+        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');
+    }
+
+    setupEventListeners() {
+        // Save button
+        document.getElementById('savePatientBtn').addEventListener('click', () => {
+            this.savePatientData();
+        });
+
+        // Refresh button
+        document.getElementById('refreshPatientBtn').addEventListener('click', () => {
+            this.loadPatientData();
+        });
+
+        // Export button
+        document.getElementById('exportPatientBtn').addEventListener('click', () => {
+            this.exportPatientData();
+        });
+
+        // Add medication button
+        document.getElementById('addMedicationBtn').addEventListener('click', () => {
+            this.addMedication();
+        });
+
+        // Add medication on Enter key
+        document.getElementById('newMedicationInput').addEventListener('keydown', (e) => {
+            if (e.key === 'Enter') {
+                this.addMedication();
+            }
+        });
+    }
+
+    async loadPatientData() {
+        this.showLoading(true);
+        
+        try {
+            // Load patient data
+            const patientResp = await fetch(`/patients/${this.patientId}`);
+            if (!patientResp.ok) {
+                throw new Error('Failed to load patient data');
+            }
+            
+            this.patientData = await patientResp.json();
+            this.populatePatientForm();
+            
+            // Load patient sessions
+            await this.loadPatientSessions();
+            
+        } catch (error) {
+            console.error('Error loading patient data:', error);
+            this.showError('Failed to load patient data. Please try again.');
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    populatePatientForm() {
+        if (!this.patientData) return;
+
+        // Update header
+        document.getElementById('patientName').textContent = this.patientData.name || 'Unknown';
+        document.getElementById('patientId').textContent = `ID: ${this.patientData.patient_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('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();
+    }
+
+    renderMedications() {
+        const container = document.getElementById('medicationsList');
+        container.innerHTML = '';
+
+        if (this.medications.length === 0) {
+            container.innerHTML = '<div style="color: var(--text-secondary); font-style: italic;">No medications listed</div>';
+            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>
+                </button>
+            `;
+            container.appendChild(tag);
+        });
+
+        // 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);
+            });
+        });
+    }
+
+    addMedication() {
+        const input = document.getElementById('newMedicationInput');
+        const medication = input.value.trim();
+        
+        if (!medication) return;
+        
+        this.medications.push(medication);
+        this.renderMedications();
+        input.value = '';
+    }
+
+    removeMedication(index) {
+        this.medications.splice(index, 1);
+        this.renderMedications();
+    }
+
+    async loadPatientSessions() {
+        try {
+            const resp = await fetch(`/patients/${this.patientId}/sessions`);
+            if (resp.ok) {
+                const data = await resp.json();
+                this.sessions = data.sessions || [];
+                this.renderSessions();
+            }
+        } catch (error) {
+            console.error('Error loading sessions:', error);
+        }
+    }
+
+    renderSessions() {
+        const container = document.getElementById('sessionsContainer');
+        
+        if (this.sessions.length === 0) {
+            container.innerHTML = '<div style="color: var(--text-secondary); font-style: italic;">No chat sessions found</div>';
+            return;
+        }
+
+        container.innerHTML = '';
+        
+        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>
+            `;
+            
+            sessionEl.addEventListener('click', () => {
+                // Could open session details or redirect to main page with session
+                window.location.href = `/?session_id=${session.session_id}`;
+            });
+            
+            container.appendChild(sessionEl);
+        });
+    }
+
+    async savePatientData() {
+        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,
+                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(`/patients/${this.patientId}`, {
+                method: 'PATCH',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(updateData)
+            });
+
+            if (resp.ok) {
+                this.showSuccess('Patient data saved successfully!');
+                // Update the header with new name
+                document.getElementById('patientName').textContent = updateData.name || 'Unknown';
+            } else {
+                throw new Error('Failed to save patient data');
+            }
+        } catch (error) {
+            console.error('Error saving patient data:', error);
+            this.showError('Failed to save patient data. Please try again.');
+        } finally {
+            this.showLoading(false);
+        }
+    }
+
+    exportPatientData() {
+        if (!this.patientData) {
+            this.showError('No patient data to export');
+            return;
+        }
+
+        const exportData = {
+            patient_id: this.patientData.patient_id,
+            name: this.patientData.name,
+            age: this.patientData.age,
+            sex: this.patientData.sex,
+            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: new Date().toISOString(),
+            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.patient_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();
+    }
+
+    showLoading(show) {
+        const overlay = document.getElementById('loadingOverlay');
+        if (overlay) {
+            overlay.style.display = show ? 'flex' : 'none';
+        }
+    }
+
+    showError(message) {
+        alert('Error: ' + message);
+    }
+
+    showSuccess(message) {
+        alert('Success: ' + message);
+    }
+}
+
+// Initialize EMR when DOM is loaded
+document.addEventListener('DOMContentLoaded', () => {
+    new PatientEMR();
+});

static/js/patient.js

@@ -0,0 +1,131 @@
+document.addEventListener('DOMContentLoaded', () => {
+	const form = document.getElementById('patientForm');
+	const result = document.getElementById('result');
+	const cancelBtn = document.getElementById('cancelBtn');
+	const successModal = document.getElementById('patientSuccessModal');
+	const successClose = document.getElementById('patientSuccessClose');
+	const successReturn = document.getElementById('patientSuccessReturn');
+	const successEdit = document.getElementById('patientSuccessEdit');
+	const createdIdEl = document.getElementById('createdPatientId');
+	const submitBtn = form?.querySelector('button[type="submit"]');
+	const titleEl = document.querySelector('h1');
+
+	let isEditMode = false;
+	let currentPatientId = null;
+
+	function getPatientIdFromUrl() {
+		const urlParams = new URLSearchParams(window.location.search);
+		const pidFromUrl = urlParams.get('patient_id');
+		if (pidFromUrl && /^\d{8}$/.test(pidFromUrl)) return pidFromUrl;
+		return null;
+	}
+
+	async function loadPatientIntoForm(patientId) {
+		try {
+			const resp = await fetch(`/patients/${patientId}`);
+			if (!resp.ok) return;
+			const data = await resp.json();
+			document.getElementById('name').value = data.name || '';
+			document.getElementById('age').value = data.age ?? '';
+			document.getElementById('sex').value = data.sex || 'Other';
+			document.getElementById('address').value = data.address || '';
+			document.getElementById('phone').value = data.phone || '';
+			document.getElementById('email').value = data.email || '';
+			document.getElementById('medications').value = Array.isArray(data.medications) ? data.medications.join('\n') : '';
+			document.getElementById('summary').value = data.past_assessment_summary || '';
+		} catch (e) {
+			console.warn('Failed to load patient profile for editing', e);
+		}
+	}
+
+	function enableEditMode(patientId) {
+		isEditMode = true;
+		currentPatientId = patientId;
+		if (submitBtn) submitBtn.textContent = 'Update';
+		if (titleEl) titleEl.textContent = 'Edit Patient';
+	}
+
+	// Initialize: only enter edit mode if patient_id is explicitly in URL
+	const pidFromUrl = getPatientIdFromUrl();
+	if (pidFromUrl) {
+		enableEditMode(pidFromUrl);
+		loadPatientIntoForm(pidFromUrl);
+	}
+
+	cancelBtn.addEventListener('click', () => {
+		window.location.href = '/';
+	});
+
+	form.addEventListener('submit', async (e) => {
+		e.preventDefault();
+		result.textContent = '';
+		result.style.color = '';
+		const payload = {
+			name: document.getElementById('name').value.trim(),
+			age: parseInt(document.getElementById('age').value, 10),
+			sex: document.getElementById('sex').value,
+			address: document.getElementById('address').value.trim() || null,
+			phone: document.getElementById('phone').value.trim() || null,
+			email: document.getElementById('email').value.trim() || null,
+			medications: document.getElementById('medications').value.split('\n').map(s => s.trim()).filter(Boolean),
+			past_assessment_summary: document.getElementById('summary').value.trim() || null
+		};
+		try {
+			if (isEditMode && currentPatientId) {
+				const resp = await fetch(`/patients/${currentPatientId}`, {
+					method: 'PATCH',
+					headers: { 'Content-Type': 'application/json' },
+					body: JSON.stringify(payload)
+				});
+				if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+				result.textContent = 'Patient updated successfully.';
+				result.style.color = 'green';
+			} else {
+				const resp = await fetch('/patients', {
+					method: 'POST',
+					headers: { 'Content-Type': 'application/json' },
+					body: JSON.stringify(payload)
+				});
+				if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+				const data = await resp.json();
+				const pid = data.patient_id;
+				localStorage.setItem('medicalChatbotPatientId', pid);
+				
+				// Add to localStorage for future suggestions
+				const existingPatients = JSON.parse(localStorage.getItem('medicalChatbotPatients') || '[]');
+				const newPatient = {
+					patient_id: pid,
+					name: payload.name,
+					age: payload.age,
+					sex: payload.sex
+				};
+				// Check if patient already exists to avoid duplicates
+				const exists = existingPatients.some(p => p.patient_id === pid);
+				if (!exists) {
+					existingPatients.push(newPatient);
+					localStorage.setItem('medicalChatbotPatients', JSON.stringify(existingPatients));
+				}
+				
+				// Show success modal (stay in create view until user opts to edit)
+				if (createdIdEl) createdIdEl.textContent = pid;
+				successModal.classList.add('show');
+			}
+		} catch (err) {
+			console.error(err);
+			result.textContent = isEditMode ? 'Failed to update patient. Please try again.' : 'Failed to create patient. Please try again.';
+			result.style.color = 'crimson';
+		}
+	});
+
+	// Success modal wiring
+	if (successClose) successClose.addEventListener('click', () => successModal.classList.remove('show'));
+	if (successReturn) successReturn.addEventListener('click', () => { window.location.href = '/'; });
+	if (successEdit) successEdit.addEventListener('click', () => {
+		successModal.classList.remove('show');
+		const pid = createdIdEl?.textContent?.trim() || localStorage.getItem('medicalChatbotPatientId');
+		if (pid && /^\d{8}$/.test(pid)) {
+			enableEditMode(pid);
+			loadPatientIntoForm(pid);
+		}
+	});
+});

static/js/ui/doctor.js

@@ -0,0 +1,124 @@
+// ui/doctor.js
+// Doctor list load/save, dropdown populate, create-flow, show/save profile
+
+export function attachDoctorUI(app) {
+	// Model: list of doctors persisted in localStorage
+	app.loadDoctors = function () {
+		try {
+			const raw = localStorage.getItem('medicalChatbotDoctors');
+			const arr = raw ? JSON.parse(raw) : [];
+			const seen = new Set();
+			return arr.filter(x => x && x.name && !seen.has(x.name) && seen.add(x.name));
+		} catch { return []; }
+	};
+
+	app.saveDoctors = function () {
+		localStorage.setItem('medicalChatbotDoctors', JSON.stringify(app.doctors));
+	};
+
+	app.populateDoctorSelect = function () {
+		const sel = document.getElementById('profileNameSelect');
+		const newSec = document.getElementById('newDoctorSection');
+		if (!sel) return;
+		sel.innerHTML = '';
+		const createOpt = document.createElement('option');
+		createOpt.value = '__create__';
+		createOpt.textContent = 'Create doctor user...';
+		sel.appendChild(createOpt);
+		// Ensure no duplicates, include current doctor
+		const names = new Set(app.doctors.map(d => d.name));
+		if (app.currentUser?.name && !names.has(app.currentUser.name)) {
+			app.doctors.unshift({ name: app.currentUser.name });
+			names.add(app.currentUser.name);
+			app.saveDoctors();
+		}
+		app.doctors.forEach(d => {
+			const opt = document.createElement('option');
+			opt.value = d.name;
+			opt.textContent = d.name;
+			if (app.currentUser?.name === d.name) opt.selected = true;
+			sel.appendChild(opt);
+		});
+		sel.addEventListener('change', () => {
+			if (sel.value === '__create__') {
+				newSec.style.display = '';
+				const input = document.getElementById('newDoctorName');
+				if (input) input.value = '';
+			} else {
+				newSec.style.display = 'none';
+			}
+		});
+		const cancelBtn = document.getElementById('cancelNewDoctor');
+		const confirmBtn = document.getElementById('confirmNewDoctor');
+		if (cancelBtn) cancelBtn.onclick = () => { newSec.style.display = 'none'; sel.value = app.currentUser?.name || ''; };
+		if (confirmBtn) confirmBtn.onclick = () => {
+			const name = (document.getElementById('newDoctorName').value || '').trim();
+			if (!name) return;
+			if (!app.doctors.find(d => d.name === name)) {
+				app.doctors.unshift({ name });
+				app.saveDoctors();
+			}
+			app.populateDoctorSelect();
+			sel.value = name;
+			newSec.style.display = 'none';
+		};
+	};
+
+	app.showUserModal = function () {
+		app.populateDoctorSelect();
+		const sel = document.getElementById('profileNameSelect');
+		if (sel && sel.options.length === 0) {
+			const createOpt = document.createElement('option');
+			createOpt.value = '__create__';
+			createOpt.textContent = 'Create doctor user...';
+			sel.appendChild(createOpt);
+		}
+		if (sel && !sel.value) sel.value = app.currentUser?.name || '__create__';
+		document.getElementById('profileRole').value = app.currentUser.role;
+		document.getElementById('profileSpecialty').value = app.currentUser.specialty || '';
+		app.showModal('userModal');
+	};
+
+	app.saveUserProfile = function () {
+		const nameSel = document.getElementById('profileNameSelect');
+		const name = nameSel ? nameSel.value : '';
+		const role = document.getElementById('profileRole').value;
+		const specialty = document.getElementById('profileSpecialty').value.trim();
+
+		if (!name || name === '__create__') {
+			alert('Please select or create a doctor name.');
+			return;
+		}
+
+		if (!app.doctors.find(d => d.name === name)) {
+			app.doctors.unshift({ name });
+			app.saveDoctors();
+		}
+
+		app.currentUser.name = name;
+		app.currentUser.role = role;
+		app.currentUser.specialty = specialty;
+
+		app.saveUser();
+		app.updateUserDisplay();
+		app.hideModal('userModal');
+	};
+
+	// Doctor modal open/close wiring
+	document.addEventListener('DOMContentLoaded', () => {
+		const doctorCard = document.getElementById('userProfile');
+		const userModal = document.getElementById('userModal');
+		const closeBtn = document.getElementById('userModalClose');
+		const cancelBtn = document.getElementById('userModalCancel');
+		if (doctorCard && userModal) {
+			doctorCard.addEventListener('click', () => userModal.classList.add('show'));
+		}
+		if (closeBtn) closeBtn.addEventListener('click', () => userModal.classList.remove('show'));
+		if (cancelBtn) cancelBtn.addEventListener('click', () => userModal.classList.remove('show'));
+		if (userModal) {
+			userModal.addEventListener('click', (e) => { if (e.target === userModal) userModal.classList.remove('show'); });
+		}
+	});
+}
+
+

static/js/ui/handlers.js

@@ -0,0 +1,68 @@
+// ui/handlers.js
+// DOM wiring helpers: sidebar open/close, modal wiring, textarea autosize, export/clear
+
+export function attachUIHandlers(app) {
+	// Sidebar toggle implementation
+	app.toggleSidebar = function () {
+		const sidebar = document.getElementById('sidebar');
+		console.log('[DEBUG] toggleSidebar called');
+		if (sidebar) {
+			const wasOpen = sidebar.classList.contains('show');
+			sidebar.classList.toggle('show');
+			const isNowOpen = sidebar.classList.contains('show');
+			console.log('[DEBUG] Sidebar toggled - was open:', wasOpen, 'now open:', isNowOpen);
+		} else {
+			console.error('[DEBUG] Sidebar element not found');
+		}
+	};
+
+	// Textarea autosize
+	app.autoResizeTextarea = function (textarea) {
+		if (!textarea) return;
+		textarea.style.height = 'auto';
+		textarea.style.height = Math.min(textarea.scrollHeight, 120) + 'px';
+	};
+
+	// Export current chat as JSON
+	app.exportChat = function () {
+		if (!app.currentSession || app.currentSession.messages.length === 0) {
+			alert('No chat to export.');
+			return;
+		}
+		const chatData = {
+			user: app.currentUser?.name || 'Unknown',
+			session: app.currentSession.title,
+			date: new Date().toISOString(),
+			messages: app.currentSession.messages
+		};
+		const blob = new Blob([JSON.stringify(chatData, null, 2)], { type: 'application/json' });
+		const url = URL.createObjectURL(blob);
+		const a = document.createElement('a');
+		a.href = url;
+		a.download = `medical-chat-${app.currentSession.title.replace(/[^a-z0-9]/gi, '-')}.json`;
+		document.body.appendChild(a);
+		a.click();
+		document.body.removeChild(a);
+		URL.revokeObjectURL(url);
+	};
+
+	// Clear current chat
+	app.clearChat = function () {
+		if (confirm('Are you sure you want to clear this chat? This action cannot be undone.')) {
+			app.clearChatMessages();
+			if (app.currentSession) {
+				app.currentSession.messages = [];
+				app.currentSession.title = 'New Chat';
+				app.updateChatTitle();
+			}
+		}
+	};
+
+	// Generic modal helpers
+	app.showModal = function (modalId) {
+		document.getElementById(modalId)?.classList.add('show');
+	};
+	app.hideModal = function (modalId) {
+		document.getElementById(modalId)?.classList.remove('show');
+	};
+}

static/js/ui/patient.js

@@ -0,0 +1,246 @@
+// ui/patient.js
+// Patient selection, typeahead search, load/hydrate, patient modal wiring
+
+export function attachPatientUI(app) {
+	// State helpers
+	app.loadSavedPatientId = function () {
+		const pid = localStorage.getItem('medicalChatbotPatientId');
+		if (pid && /^\d{8}$/.test(pid)) {
+			app.currentPatientId = pid;
+			const status = document.getElementById('patientStatus');
+			if (status) {
+				status.textContent = `Patient: ${pid}`;
+				status.style.color = 'var(--text-secondary)';
+			}
+			const input = document.getElementById('patientIdInput');
+			if (input) input.value = pid;
+		}
+	};
+
+	app.savePatientId = function () {
+		if (app.currentPatientId) localStorage.setItem('medicalChatbotPatientId', app.currentPatientId);
+		else localStorage.removeItem('medicalChatbotPatientId');
+	};
+
+	app.loadPatient = async function () {
+		console.log('[DEBUG] loadPatient called');
+		const input = document.getElementById('patientIdInput');
+		const status = document.getElementById('patientStatus');
+		const id = (input?.value || '').trim();
+		console.log('[DEBUG] Patient ID from input:', id);
+		if (!/^\d{8}$/.test(id)) {
+			console.log('[DEBUG] Invalid patient ID format');
+			if (status) { status.textContent = 'Invalid patient ID. Use 8 digits.'; status.style.color = 'var(--warning-color)'; }
+			return;
+		}
+		console.log('[DEBUG] Setting current patient ID:', id);
+		app.currentPatientId = id;
+		app.savePatientId();
+		if (status) { status.textContent = `Patient: ${id}`; status.style.color = 'var(--text-secondary)'; }
+		await app.fetchAndRenderPatientSessions();
+	};
+
+	app.fetchAndRenderPatientSessions = async function () {
+		if (!app.currentPatientId) return;
+		try {
+			const resp = await fetch(`/patients/${app.currentPatientId}/sessions`);
+			if (resp.ok) {
+				const data = await resp.json();
+				const sessions = Array.isArray(data.sessions) ? data.sessions : [];
+				app.backendSessions = sessions.map(s => ({
+					id: s.session_id,
+					title: s.title || 'New Chat',
+					messages: [],
+					createdAt: s.created_at || new Date().toISOString(),
+					lastActivity: s.last_activity || new Date().toISOString(),
+					source: 'backend'
+				}));
+				if (app.backendSessions.length > 0) {
+					app.currentSession = app.backendSessions[0];
+					await app.hydrateMessagesForSession(app.currentSession.id);
+				}
+			} else {
+				console.warn('Failed to fetch patient sessions', resp.status);
+				app.backendSessions = [];
+			}
+		} catch (e) {
+			console.error('Failed to load patient sessions', e);
+			app.backendSessions = [];
+		}
+		app.loadChatSessions();
+	};
+
+	app.hydrateMessagesForSession = async function (sessionId) {
+		try {
+			const resp = await fetch(`/sessions/${sessionId}/messages?patient_id=${app.currentPatientId}&limit=1000`);
+			if (!resp.ok) return;
+			const data = await resp.json();
+			const msgs = Array.isArray(data.messages) ? data.messages : [];
+			const normalized = msgs.map(m => ({
+				id: m._id || app.generateId(),
+				role: m.role,
+				content: m.content,
+				timestamp: m.timestamp
+			}));
+			if (app.currentSession && app.currentSession.id === sessionId) {
+				app.currentSession.messages = normalized;
+				app.clearChatMessages();
+				app.currentSession.messages.forEach(m => app.displayMessage(m));
+				app.updateChatTitle();
+			}
+		} catch (e) {
+			console.error('Failed to hydrate session messages', e);
+		}
+	};
+
+	// Bind patient input + typeahead + load button
+	app.bindPatientHandlers = function () {
+		console.log('[DEBUG] bindPatientHandlers called');
+		const loadBtn = document.getElementById('loadPatientBtn');
+		console.log('[DEBUG] Load button found:', !!loadBtn);
+		if (loadBtn) loadBtn.addEventListener('click', () => app.loadPatient());
+		const patientInput = document.getElementById('patientIdInput');
+		const suggestionsEl = document.getElementById('patientSuggestions');
+		console.log('[DEBUG] Patient input found:', !!patientInput);
+		console.log('[DEBUG] Suggestions element found:', !!suggestionsEl);
+		if (!patientInput) return;
+		let debounceTimer;
+		const hideSuggestions = () => { if (suggestionsEl) suggestionsEl.style.display = 'none'; };
+		const renderSuggestions = (items) => {
+			if (!suggestionsEl) return;
+			if (!items || items.length === 0) { hideSuggestions(); return; }
+			suggestionsEl.innerHTML = '';
+			items.forEach(p => {
+				const div = document.createElement('div');
+				div.className = 'patient-suggestion';
+				div.textContent = `${p.name || 'Unknown'} (${p.patient_id})`;
+				div.addEventListener('click', async () => {
+					app.currentPatientId = p.patient_id;
+					app.savePatientId();
+					patientInput.value = p.patient_id;
+					hideSuggestions();
+					const status = document.getElementById('patientStatus');
+					if (status) { status.textContent = `Patient: ${p.patient_id}`; status.style.color = 'var(--text-secondary)'; }
+					await app.fetchAndRenderPatientSessions();
+				});
+				suggestionsEl.appendChild(div);
+			});
+			suggestionsEl.style.display = 'block';
+		};
+		patientInput.addEventListener('input', () => {
+			const q = patientInput.value.trim();
+			console.log('[DEBUG] Patient input changed:', q);
+			clearTimeout(debounceTimer);
+			if (!q) { hideSuggestions(); return; }
+			debounceTimer = setTimeout(async () => {
+				try {
+					console.log('[DEBUG] Searching patients with query:', q);
+					const resp = await fetch(`/patients/search?q=${encodeURIComponent(q)}&limit=8`, { headers: { 'Accept': 'application/json' } });
+					console.log('[DEBUG] Search response status:', resp.status);
+					if (resp.ok) {
+						const data = await resp.json();
+						console.log('[DEBUG] Search results:', data);
+						renderSuggestions(data.results || []);
+					} else {
+						console.warn('Search request failed', resp.status);
+					}
+				} catch (e) { 
+					console.error('[DEBUG] Search error:', e);
+				}
+			}, 200);
+		});
+		patientInput.addEventListener('keydown', async (e) => {
+			if (e.key === 'Enter') {
+				const value = patientInput.value.trim();
+				console.log('[DEBUG] Patient input Enter pressed with value:', value);
+				if (/^\d{8}$/.test(value)) {
+					console.log('[DEBUG] Loading patient with 8-digit ID');
+					await app.loadPatient();
+					hideSuggestions();
+				} else {
+					console.log('[DEBUG] Searching for patient by name/partial ID');
+					try {
+						const resp = await fetch(`/patients/search?q=${encodeURIComponent(value)}&limit=1`);
+						console.log('[DEBUG] Search response status:', resp.status);
+						if (resp.ok) {
+							const data = await resp.json();
+							console.log('[DEBUG] Search results for Enter:', data);
+							const first = (data.results || [])[0];
+							if (first) {
+								console.log('[DEBUG] Found patient, setting as current:', first);
+								app.currentPatientId = first.patient_id;
+								app.savePatientId();
+								patientInput.value = first.patient_id;
+								hideSuggestions();
+								const status = document.getElementById('patientStatus');
+								if (status) { status.textContent = `Patient: ${first.patient_id}`; status.style.color = 'var(--text-secondary)'; }
+								await app.fetchAndRenderPatientSessions();
+								return;
+							}
+						}
+					} catch (e) {
+						console.error('[DEBUG] Search error on Enter:', e);
+					}
+					const status = document.getElementById('patientStatus');
+					if (status) { status.textContent = 'No matching patient found'; status.style.color = 'var(--warning-color)'; }
+				}
+			}
+		});
+		document.addEventListener('click', (ev) => {
+			if (!suggestionsEl) return;
+			if (!suggestionsEl.contains(ev.target) && ev.target !== patientInput) hideSuggestions();
+		});
+	};
+
+	// Patient modal wiring
+	document.addEventListener('DOMContentLoaded', () => {
+		const profileBtn = document.getElementById('patientMenuBtn');
+		const modal = document.getElementById('patientModal');
+		const closeBtn = document.getElementById('patientModalClose');
+		const logoutBtn = document.getElementById('patientLogoutBtn');
+		const createBtn = document.getElementById('patientCreateBtn');
+		if (profileBtn && modal) {
+			profileBtn.addEventListener('click', async () => {
+				const pid = app?.currentPatientId;
+				if (pid) {
+					try {
+						const resp = await fetch(`/patients/${pid}`);
+						if (resp.ok) {
+							const p = await resp.json();
+							const name = p.name || 'Unknown';
+							const age = typeof p.age === 'number' ? p.age : '-';
+							const sex = p.sex || '-';
+							const meds = Array.isArray(p.medications) && p.medications.length > 0 ? p.medications.join(', ') : '-';
+							document.getElementById('patientSummary').textContent = `${name} — ${sex}, ${age}`;
+							document.getElementById('patientMedications').textContent = meds;
+							document.getElementById('patientAssessment').textContent = p.past_assessment_summary || '-';
+						}
+					} catch (e) {
+						console.error('Failed to load patient profile', e);
+					}
+				}
+				modal.classList.add('show');
+			});
+		}
+		if (closeBtn && modal) {
+			closeBtn.addEventListener('click', () => modal.classList.remove('show'));
+			modal.addEventListener('click', (e) => { if (e.target === modal) modal.classList.remove('show'); });
+		}
+		if (logoutBtn) {
+			logoutBtn.addEventListener('click', () => {
+				if (confirm('Log out current patient?')) {
+					app.currentPatientId = null;
+					localStorage.removeItem('medicalChatbotPatientId');
+					const status = document.getElementById('patientStatus');
+					if (status) { status.textContent = 'No patient selected'; status.style.color = 'var(--text-secondary)'; }
+					const input = document.getElementById('patientIdInput');
+					if (input) input.value = '';
+					modal.classList.remove('show');
+				}
+			});
+		}
+		if (createBtn) createBtn.addEventListener('click', () => modal.classList.remove('show'));
+	});
+}
+
+

static/js/ui/settings.js

@@ -0,0 +1,74 @@
+// ui/settings.js
+// Settings UI: theme/font preferences, showLoading overlay, settings modal wiring
+
+export function attachSettingsUI(app) {
+	app.loadUserPreferences = function () {
+		const preferences = localStorage.getItem('medicalChatbotPreferences');
+		if (preferences) {
+			const prefs = JSON.parse(preferences);
+			app.setTheme(prefs.theme || 'auto');
+			app.setFontSize(prefs.fontSize || 'medium');
+		}
+	};
+
+	app.setupTheme = function () {
+		if (window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches) {
+			app.setTheme('auto');
+		}
+	};
+
+	app.setTheme = function (theme) {
+		const root = document.documentElement;
+		if (theme === 'auto') {
+			const isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+			root.setAttribute('data-theme', isDark ? 'dark' : 'light');
+		} else {
+			root.setAttribute('data-theme', theme);
+		}
+		const sel = document.getElementById('themeSelect');
+		if (sel) sel.value = theme;
+		app.savePreferences();
+	};
+
+	app.setFontSize = function (size) {
+		const root = document.documentElement;
+		root.style.fontSize = size === 'small' ? '14px' : size === 'large' ? '18px' : '16px';
+		app.savePreferences();
+	};
+
+	app.savePreferences = function () {
+		const preferences = {
+			theme: document.getElementById('themeSelect')?.value,
+			fontSize: document.getElementById('fontSize')?.value,
+			autoSave: document.getElementById('autoSave')?.checked,
+			notifications: document.getElementById('notifications')?.checked
+		};
+		localStorage.setItem('medicalChatbotPreferences', JSON.stringify(preferences));
+	};
+
+	app.showLoading = function (show) {
+		app.isLoading = show;
+		const overlay = document.getElementById('loadingOverlay');
+		const sendBtn = document.getElementById('sendBtn');
+		if (!overlay || !sendBtn) return;
+		if (show) {
+			overlay.classList.add('show');
+			sendBtn.disabled = true;
+		} else {
+			overlay.classList.remove('show');
+			sendBtn.disabled = false;
+		}
+	};
+
+	// Settings modal open/close wiring
+	document.addEventListener('DOMContentLoaded', () => {
+		const settingsBtn = document.getElementById('settingsBtn');
+		const modal = document.getElementById('settingsModal');
+		const closeBtn = document.getElementById('settingsModalClose');
+		const cancelBtn = document.getElementById('settingsModalCancel');
+		if (settingsBtn && modal) settingsBtn.addEventListener('click', () => modal.classList.add('show'));
+		if (closeBtn) closeBtn.addEventListener('click', () => modal.classList.remove('show'));
+		if (cancelBtn) cancelBtn.addEventListener('click', () => modal.classList.remove('show'));
+		if (modal) modal.addEventListener('click', (e) => { if (e.target === modal) modal.classList.remove('show'); });
+	});
+}

static/patient.html

@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Create Patient</title>
+    <link rel="stylesheet" href="/static/css/patient.css">
+    <link rel="icon" type="image/svg+xml" href="/static/icon.svg">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
+</head>
+<body>
+    <div class="container">
+        <a href="/" class="back-link"><i class="fas fa-arrow-left"></i> Back to Assistant</a>
+        <h1>Create Patient</h1>
+        <form id="patientForm">
+            <div class="grid">
+                <label>Name<input type="text" id="name" required></label>
+                <label>Age<input type="number" id="age" min="0" max="130" required></label>
+                <label>Sex
+                    <select id="sex" required>
+                        <option value="Male">Male</option>
+                        <option value="Female">Female</option>
+                        <option value="Other">Other</option>
+                    </select>
+                </label>
+                <label>Phone<input type="tel" id="phone"></label>
+                <label>Email<input type="email" id="email"></label>
+                <label>Address<input type="text" id="address"></label>
+                <label>Active Medications<textarea id="medications" placeholder="One per line"></textarea></label>
+                <label>Past Assessment Summary<textarea id="summary"></textarea></label>
+            </div>
+            <div class="actions">
+                <button type="button" id="cancelBtn" class="secondary">Cancel</button>
+                <button type="submit" class="primary">Create</button>
+            </div>
+        </form>
+        <div id="result" class="result"></div>
+    </div>
+    <!-- Success Modal -->
+    <div class="modal" id="patientSuccessModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3>Patient Created</h3>
+                <button class="modal-close" id="patientSuccessClose">&times;</button>
+            </div>
+            <div class="modal-body">
+                <p>Your new Patient ID is:</p>
+                <div id="createdPatientId" class="big-id"></div>
+            </div>
+            <div class="modal-footer">
+                <button class="secondary" id="patientSuccessReturn">Return to main page</button>
+                <button class="primary" id="patientSuccessEdit">Edit patient profile</button>
+            </div>
+        </div>
+    </div>
+
+    <script src="/static/js/patient.js"></script>
+</body>
+</html>