Upd README

README.md

@@ -13,337 +13,150 @@ 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
+- **Export Functionality**: Export chat sessions for medical records or educational 
+purposes
 
-## ✨ Recent Updates (Mongo-backed memory & patient context)
-- **Long-term memory in MongoDB**: Up to 20 latest QA summaries per patient are persisted for RAG continuity.
-- **Short-term cache**: Last 3 summaries are kept in an in-memory LRU for immediate context.
-- **Chat history persistence**: All chat messages are stored in MongoDB per session.
-- **Patient/Doctor context**:
-  - Frontend sidebar now includes a Patient ID input (8 digits).
-  - Backend accepts `patient_id` and `doctor_id` and saves data per patient with assigned doctor.
-- **Context retrieval**: Combines short-term cache (3) with long-term Mongo (20) for robust continuity.
+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/mongodb.py`: Mongo helpers (sessions, messages, memory, patients, search)
+- `src/api/routes/`: `chat`, `session`, `user` (patients), `system`, `static`
 
-## 🏗️ Architecture
+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`)
 
-### 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
+## 🛠️ 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
-   # MongoDB (required for persistence)
-   echo "MONGO_USER=your_mongodb_connection_string" >> .env
-   # Optional: override DB name (default: medicaldiagnosissystem)
-   echo "MONGO_DB=medicaldiagnosissystem" >> .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
-- `MONGO_USER`: MongoDB connection string (Atlas or local)
-- `MONGO_DB`: MongoDB database name (default: `medicaldiagnosissystem`)
-- `LOG_LEVEL`: Logging level (DEBUG, INFO, WARNING, ERROR)
-- `PORT`: Server port (default: 8000)
-
-### Memory Settings
-- **LRU Capacity (short-term cache)**: Default 3 QA summaries per patient/user (fast context)
-- **Long-term Memory**: Up to 20 persisted summaries per patient in MongoDB
-- **Max Sessions**: Default 20 sessions per user
+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)
+echo "MONGO_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. **Select Patient**: Enter an 8-digit Patient ID in the sidebar and press the patient icon or Enter
-4. **Start New Chat**: Click "New Chat" to begin a conversation
-5. **Ask Medical Questions**: Type your medical queries in natural language
-6. **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
-
-## 🔌 API Endpoints (selected)
-- `POST /chat`
-  - Body: `{ user_id, patient_id, doctor_id, session_id, message, user_role?, user_specialty?, title? }`
-  - Returns: `{ response, session_id, timestamp, medical_context? }`
-- `POST /sessions`
-  - Body: `{ user_id, patient_id, doctor_id, title? }`
-  - Returns: `{ session_id }`
-- `GET /patients/{patient_id}/sessions`: List sessions for a patient (Mongo)
-- `GET /sessions/{session_id}/messages`: List messages in a session (Mongo)
-
-## 🔒 Security & Privacy
-
-### Data Protection
-- **MongoDB Persistence**: Chat history and long-term memory are stored in MongoDB keyed by `patient_id` with `doctor_id` attribution.
-- **Local Storage (UI)**: The sidebar may cache view state locally for UX; authoritative history is in MongoDB.
-- **PII Handling**: Ensure no sensitive PHI is logged; configure Mongo access securely.
-- **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`
+- `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/
+│   │   └── mongodb.py           # Mongo helpers (sessions, messages, memory, patients)
+│   ├── 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/extend endpoints under `src/api/routes`
-2. **Memory**: Extend cache logic in `src/core/memory/memory.py` and persistence in `src/data/mongodb.py`
-3. **Frontend**: Update UI components in `static/` files
-4. **Testing**: Add tests for new functionality
-
-## 🚀 Deployment
-
-### Production Considerations
-- **Environment Variables**: Secure API key and database management
-- **HTTPS**: Enable SSL/TLS for production
-- **Rate Limiting**: Implement request rate limiting
-- **Monitoring**: Add health checks and logging
-- **Database**: Ensure MongoDB backups and appropriate indexes
-
-### 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
-- **Database**: Ensure `MONGO_USER` is configured and reachable
-- **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

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.
+
+