Revert "Merge branch 'FT-DEV-17/09/2025'"

This reverts commit 715f2878b980fc505d7114dbecf45bcd9357f2ea, reversing
changes made to 11a4a59e6aa7a42c5e9997141b04dc042803ca0c.

.env

@@ -3,10 +3,4 @@ HF_HOME=/tmp/huggingface
 XDG_CACHE_HOME=/tmp
 TORCH_HOME=/tmp/torch
 WHISPER_CACHE=/tmp/whisper
-UPLOAD_DIR=/tmp/uploads
-
-# Redis configuration (uncomment to enable scalable features)
-# REDIS_URL=redis://localhost:6379/0
-
-# Database configuration for audit logging (optional)
-# DATABASE_URL=postgresql://username:password@localhost:5432/audit_db
+UPLOAD_DIR=/tmp/uploads

.env.example

@@ -1,16 +0,0 @@
-# .env.example - Environment configuration for local development
-
-# Database configuration
-DATABASE_URL=postgresql://user:password@localhost:5432/hnai_db
-
-# API Key for external services
-API_KEY=your-api-key-here
-
-# Secret key for cryptographic signing
-SECRET_KEY=your-secret-key-here
-
-# Debug mode
-DEBUG=True
-
-# Application port
-PORT=8000

.huggingface.yaml

@@ -1,7 +1,6 @@
 runtime: docker
 sdk: docker
 python_version: "3.10"
-app: services/ai-service/src/ai_med_extract/app.py
 build:
   system_packages:
     - tesseract-ocr

.vscode/launch.json

@@ -1,22 +0,0 @@
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "Python: FastAPI (Localhost)",
-            "type": "debugpy",
-            "request": "launch",
-            "module": "uvicorn",
-            "args": [
-                "src.ai_med_extract.app:create_app",
-                "--factory",
-                "--host", "127.0.0.1",
-                "--port", "8000",
-                "--reload"
-            ],
-            "cwd": "${workspaceFolder}/services/ai-service",
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}/services/ai-service"
-            }
-        }
-    ]
-}

.vscode/settings.json

@@ -1,6 +1,5 @@
 {
     "python.analysis.extraPaths": [
-        "./ai_med_extract/utils",
-        "./services/ai-service/src"
+        "./ai_med_extract/utils"
     ]
 }

DEPLOYMENT.md

@@ -1,106 +1,13 @@
-# Deployment Instructions
+# Hugging Face Spaces Docker deployment instructions
 
-This document provides deployment instructions for the Medical AI Service in various environments.
+# 1. Make sure your Dockerfile exposes port 7860 and runs your app on 0.0.0.0:7860
+# 2. Your Flask app should listen on host='0.0.0.0' and port=7860
+# 3. requirements.txt should include all dependencies
+# 4. .huggingface.yaml with 'runtime: docker' is present
+# 5. .dockerignore and .gitignore are present
 
-## Local Development
+# To test locally:
+# docker build -t hntai-app .
+# docker run -p 7860:7860 hntai-app
 
-### Prerequisites
-- Python 3.10+
-- Docker (optional, for containerized testing)
-
-### Setup
-1. Clone the repository
-2. Install dependencies: `pip install -r requirements.txt`
-3. Set environment variables (see Configuration section)
-4. Run the application: `python -m uvicorn ai_med_extract.app:create_app --host 0.0.0.0 --port 7860`
-
-### Testing
-- Health check: `curl http://localhost:7860/health/live`
-- API docs: `http://localhost:7860/docs` (FastAPI Swagger UI)
-
-## Docker Deployment
-
-### Build and Run
-```bash
-docker build -t medical-ai-service .
-docker run -p 7860:7860 -e SECRET_KEY=your-secret -e DATABASE_URL=your-db medical-ai-service
-```
-
-### Configuration
-- Exposes port 7860
-- Runs FastAPI app with uvicorn
-- Includes model caching optimizations
-
-## Kubernetes Deployment
-
-### Prerequisites
-- Kubernetes cluster
-- kubectl configured
-- Secrets created for database, Redis, and JWT keys
-
-### Deploy
-```bash
-kubectl apply -f infra/k8s/secure_deployment.yaml
-```
-
-### Features
-- Horizontal Pod Autoscaler (2-10 replicas based on CPU/memory)
-- Resource limits: 1-4 CPU, 4-8Gi memory
-- Prometheus monitoring annotations
-- Security contexts and network policies
-
-### Scaling
-The HPA automatically scales based on:
-- CPU utilization > 70%
-- Memory utilization > 80%
-
-## Hugging Face Spaces Deployment
-
-### Prerequisites
-- Hugging Face account
-- Space created with Docker runtime
-
-### Configuration
-1. Dockerfile exposes port 7860
-2. FastAPI app listens on 0.0.0.0:7860
-3. requirements.txt includes all dependencies
-4. .huggingface.yaml with `runtime: docker`
-5. .dockerignore and .gitignore present
-
-### Deploy
-```bash
-# Test locally
-docker build -t hntai-app .
-docker run -p 7860:7860 hntai-app
-
-# Push to HF Spaces
-# App available at your-space-name.hf.space
-```
-
-## Configuration
-
-### Required Environment Variables
-- `SECRET_KEY`: Application secret key
-- `JWT_SECRET_KEY`: JWT signing key
-- `DATABASE_URL`: PostgreSQL connection string
-- `REDIS_URL`: Redis connection string
-
-### Optional
-- `ENVIRONMENT`: prod/dev (default: prod)
-- `PORT`: Service port (default: 7860)
-- `CORS_ORIGINS`: Allowed CORS origins (default: *)
-- Model cache directories and other settings in config_settings.py
-
-## Monitoring
-
-### Health Checks
-- `/health/live`: Liveness probe
-- `/health/ready`: Readiness probe
-
-### Metrics
-- `/metrics`: Prometheus metrics endpoint
-- Includes performance metrics, model loading status
-
-### Logging
-- Structured JSON logs for production
-- Configurable log levels
+# Your app will be available at http://localhost:7860

DEVELOPMENT.md

@@ -1,377 +0,0 @@
-# HNTAI - Scalable Medical Data Extraction API - Development Guide
-
-## Overview
-
-This FastAPI-based application provides scalable medical data extraction services, fully aligned with the "ChatGPT Version 3 - Scalable" architecture. It features async processing, Redis caching, PostgreSQL persistence, and enterprise-grade security.
-
-## Architecture
-
-### Core Components
-
-1. **FastAPI Application** (`app.py`)
-   - Main application factory with lifespan events
-   - CORS middleware for cross-origin requests
-   - Centralized agent initialization
-   - Route registration from APIRouter
-
-2. **Configuration** (`config_settings.py`)
-   - Pydantic-based settings with validation
-   - Environment variable loading
-   - Database and Redis URL configuration
-
-3. **Inference Service** (`inference_service.py`)
-   - Async text summarization using thread pools
-   - Model caching for performance
-   - Chunking for long text processing
-
-4. **PHI Scrubber Service** (`phi_scrubber_service.py`)
-   - Regex-based PHI detection and redaction
-   - Audit logging to PostgreSQL
-   - Redis-based statistics tracking
-
-5. **API Routes** (`api/routes_fastapi.py`)
-   - FastAPI APIRouter with async endpoints
-   - Health checks (/live, /ready)
-   - Placeholder routes for full migration
-
-### Data Flow
-
-```
-Client Request → FastAPI → Route Handler → Agent/Service → Redis Cache → PostgreSQL → Response
-```
-
-## Development Setup
-
-### Prerequisites
-
-- Python 3.10+
-- PostgreSQL 13+
-- Redis 6+
-- Docker (optional)
-
-### Local Development
-
-1. **Clone and Setup Virtual Environment**
-   ```bash
-   git clone <repository>
-   cd hntai
-   python -m venv venv
-   source venv/bin/activate  # On Windows: venv\Scripts\activate
-   ```
-
-2. **Install Dependencies**
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-3. **Setup Database and Redis**
-   ```bash
-   # Start PostgreSQL (using Docker)
-   docker run -d --name postgres -e POSTGRES_PASSWORD=password -p 5432:5432 postgres:13
-
-   # Start Redis (using Docker)
-   docker run -d --name redis -p 6379:6379 redis:6
-
-   # Create database
-   createdb medical_ai
-   ```
-
-4. **Environment Variables**
-   Create `.env` file:
-   ```bash
-   DATABASE_URL=postgresql://postgres:password@localhost:5432/medical_ai
-   REDIS_URL=redis://localhost:6379/0
-   SECRET_KEY=your-secret-key-here
-   JWT_SECRET_KEY=your-jwt-secret-key-here
-   ```
-
-5. **Run Database Migrations**
-   ```bash
-   # Apply schema
-   psql -d medical_ai -f database/postgresql/001_schema.sql
-   ```
-
-6. **Run the Application**
-   ```bash
-   # Development mode
-   python -m ai_med_extract.main
-
-   # Or directly
-   uvicorn ai_med_extract.app:create_app --reload --host 0.0.0.0 --port 7860
-   ```
-
-7. **Access the Application**
-   - API: http://localhost:7860
-   - Docs: http://localhost:7860/docs (FastAPI auto-generated)
-   - Health: http://localhost:7860/live
-
-### Debugging
-
-1. **Enable Debug Logging**
-   ```python
-   import logging
-   logging.basicConfig(level=logging.DEBUG)
-   ```
-
-2. **Use FastAPI Debug Mode**
-   ```bash
-   uvicorn ai_med_extract.app:create_app --reload --debug --host 0.0.0.0 --port 7860
-   ```
-
-3. **Test Endpoints**
-   ```bash
-   # Health check
-   curl http://localhost:7860/live
-
-   # API docs
-   curl http://localhost:7860/openapi.json
-   ```
-
-4. **Database Debugging**
-   ```bash
-   # Connect to PostgreSQL
-   psql -d medical_ai
-
-   # Check PHI audit logs
-   SELECT * FROM phi_audit_log LIMIT 10;
-   ```
-
-5. **Redis Debugging**
-   ```bash
-   # Connect to Redis CLI
-   redis-cli
-
-   # Check keys
-   KEYS *
-   ```
-
-## Production Deployment
-
-### Option 1: Docker Deployment
-
-1. **Build Docker Image**
-   ```bash
-   docker build -t hntai-api .
-   ```
-
-2. **Run Container**
-   ```bash
-   docker run -d \
-     --name hntai-api \
-     -p 7860:7860 \
-     -e DATABASE_URL=postgresql://... \
-     -e REDIS_URL=redis://... \
-     -e SECRET_KEY=... \
-     -e JWT_SECRET_KEY=... \
-     hntai-api
-   ```
-
-### Option 2: Kubernetes Deployment
-
-1. **Prerequisites**
-   - Kubernetes cluster
-   - kubectl configured
-   - PostgreSQL and Redis services running
-
-2. **Create Secrets**
-   ```bash
-   kubectl create secret generic medical-ai-secrets \
-     --from-literal=DATABASE_URL=postgresql://... \
-     --from-literal=REDIS_URL=redis://... \
-     --from-literal=SECRET_KEY=... \
-     --from-literal=JWT_SECRET_KEY=...
-   ```
-
-3. **Deploy to Kubernetes**
-   ```bash
-   kubectl apply -f infra/k8s/secure_deployment.yaml
-   ```
-
-4. **Verify Deployment**
-   ```bash
-   kubectl get pods -n medical-ai
-   kubectl logs -n medical-ai deployment/medical-ai-service
-   ```
-
-### Option 3: Hugging Face Spaces (Legacy)
-
-The application still supports HF Spaces deployment for lightweight use cases.
-
-1. **Update app.py** for HF Spaces compatibility
-2. **Deploy via HF Spaces** with Docker SDK
-
-## Monitoring and Observability
-
-### Prometheus Metrics
-
-The application exposes metrics at `/metrics` endpoint.
-
-1. **Setup Prometheus**
-   ```bash
-   kubectl apply -f monitoring/prometheus.yml
-   ```
-
-2. **Access Metrics**
-   ```bash
-   curl http://ai-service.medical-ai.svc.cluster.local:80/metrics
-   ```
-
-### Health Checks
-
-- **Liveness** (`/live`): Basic health check
-- **Readiness** (`/ready`): Checks if agents are initialized
-
-### Logging
-
-- Structured JSON logging
-- PHI operations logged to database
-- Error tracking with stack traces
-
-## Security Features
-
-### HIPAA Compliance
-
-- PHI scrubbing with audit trails
-- Non-root container execution
-- Secrets management via Kubernetes
-- Network policies restricting traffic
-
-### Authentication
-
-- JWT-based authentication (framework ready)
-- API key support (configurable)
-
-## API Usage
-
-### Health Endpoints
-
-```bash
-GET /live
-GET /ready
-```
-
-### PHI Scrubbing
-
-```bash
-POST /phi/scrub
-Content-Type: application/json
-
-{
-  "text": "Patient John Doe, SSN 123-45-6789, diagnosed with diabetes."
-}
-```
-
-Response:
-```json
-{
-  "scrubbed_text": "Patient [REDACTED], SSN [REDACTED], diagnosed with diabetes.",
-  "phi_found": ["NAME", "SSN"],
-  "redaction_count": 2
-}
-```
-
-### Text Summarization
-
-```bash
-POST /api/generate_summary
-Content-Type: application/json
-
-{
-  "text": "Long medical text...",
-  "max_length": 150,
-  "min_length": 50
-}
-```
-
-### Generate Patient Summary
-
-The `generate_patient_summary` endpoint has been migrated from the original Flask implementation to FastAPI. It generates a comprehensive 4-section patient summary from EHR data, with support for streaming (SSE) to handle long-running tasks and prevent timeouts.
-
-**Endpoint**: `POST /generate_patient_summary`
-
-**Query Parameters**:
-- `stream` (optional, default: `false`): Set to `true` for Server-Sent Events (SSE) streaming updates.
-
-**Request Body** (JSON):
-```json
-{
-  "patientid": "12345",
-  "token": "your-auth-token",
-  "key": "your-api-key",
-  "patient_summarizer_model_name": "microsoft/Phi-3-mini-4k-instruct-gguf/Phi-3-mini-4k-instruct-q4.gguf",
-  "patient_summarizer_model_type": "gguf",
-  "generation_mode": "hq",  // Options: "hq" (high-quality), "fast", "rule" (deterministic)
-  "timeout_mode": "fast"    // Options: "fast" (8s EHR timeout), "extended" (30s)
-}
-```
-
-**Synchronous Response** (when `stream=false`):
-```json
-{
-  "summary": "## Clinical Assessment\n- Patient details...\n\n## Key Trends & Changes\n- Changes detected...\n\n## Plan & Suggested Actions\n- Recommendations...\n\n## Direct Guidance for Physician\n- Clinical insights...",
-  "baseline": "Patient baseline data...",
-  "delta": "Changes from previous visits...",
-  "timing": {"ehr_api": 2.5, "generation": 15.3, "total": 17.8},
-  "model_used": "microsoft/Phi-3-mini-4k-instruct (gguf)",
-  "timeout_mode_used": "fast"
-}
-```
-
-**Streaming Response** (when `stream=true`):
-- Returns a `text/event-stream` response with SSE events:
-  - `type: progress` - Progress updates (e.g., 10%, 50%)
-  - `type: complete` - Final result with full summary
-  - `type: error` - Error details if failed
-  - `type: heartbeat` - Keep-alive signals
-
-**Notes**:
-- The endpoint integrates with an external EHR API to fetch patient data.
-- Supports multiple model types: GGUF, text-generation, summarization, seq2seq.
-- Includes fallbacks for timeouts, API errors, and model failures.
-- PHI scrubbing is applied automatically.
-- Full implementation includes delta computation, baseline building, and 4-section markdown output.
-
-### Other Endpoints (Migration in Progress)
-- `POST /upload` - File upload and text extraction
-- `POST /transcribe` - Audio transcription
-- `POST /extract_medical_data` - Structured medical data extraction
-- `POST /api/extract_medical_data_from_audio` - Audio-based medical extraction
-
-## Troubleshooting
-
-### Common Issues
-
-1. **Model Loading Failures**
-   - Check HF_HOME and cache directories
-   - Ensure sufficient memory
-   - Verify internet connectivity for model downloads
-
-2. **Database Connection Errors**
-   - Verify DATABASE_URL format
-   - Check PostgreSQL service status
-   - Ensure database exists and schema applied
-
-3. **Redis Connection Issues**
-   - Verify REDIS_URL format
-   - Check Redis service availability
-   - Monitor Redis memory usage
-
-4. **PHI Scrubbing Not Working**
-   - Check regex patterns in phi_scrubber_service.py
-   - Verify Redis connection for stats
-   - Check database audit logs
-
-### Performance Tuning
-
-- Adjust thread pools in inference_service.py
-- Configure Redis connection pooling
-- Set appropriate resource limits in K8s
-- Monitor memory usage for model caching
-
-## Contributing
-
-1. Follow async/await patterns for new endpoints
-2. Add proper error handling and logging
-3. Update tests for new functionality
-4. Ensure HIPAA compliance for PHI handling
-5. Document API changes in this guide

Dockerfile

@@ -219,4 +219,4 @@ ENTRYPOINT ["/entrypoint.sh"]
 
 EXPOSE 7860
 
-CMD ["uvicorn", "ai_med_extract.app:create_app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "--threads", "2", "--timeout", "0", "ai_med_extract.app:app"]

FINAL_PROGRESS.md

@@ -0,0 +1,72 @@
+# GGUF Timeout Fix - Complete Implementation
+
+## ✅ All Steps Completed:
+
+### 1. Increased GGUF Timeout
+- Changed from 120s to 300s for Hugging Face Spaces
+- Maintained 120s for local development
+- Made timeout configurable via `GGUF_GENERATION_TIMEOUT` environment variable
+
+### 2. Enhanced Error Handling
+- Added comprehensive timeout handling in `routes.py`
+- Implemented fallback mechanisms when GGUF model fails
+- Added better logging for debugging timeout issues
+- Created robust fallback pipeline for graceful degradation
+
+### 3. Optimized GGUF Model Parameters
+- Added CPU-specific optimizations for Hugging Face Spaces:
+  - `use_mlock=False` for better container compatibility
+  - `vocab_only=False` for full model loading
+  - `n_threads_batch=n_threads` for consistent threading
+  - `mmap=True` for memory mapping optimizations
+  - Cache type optimizations for better performance
+
+### 4. Added Progress Logging
+- Enhanced logging throughout the generation process
+- Added detailed timing information for each generation loop
+- Added validation checks for summary completeness
+- Improved debugging capabilities
+
+## 🔧 Files Modified:
+
+### `ai_med_extract/utils/model_loader_gguf.py`
+- Updated timeout handling with environment variable support
+- Optimized model initialization parameters for Spaces
+- Enhanced logging throughout the generation process
+- Added detailed progress monitoring
+
+### `ai_med_extract/api/routes.py`
+- Added comprehensive error handling for GGUF timeouts
+- Implemented fallback mechanisms when GGUF fails
+- Improved logging and error responses
+- Added graceful degradation to template-based fallback
+
+## ⚙️ Configuration Options:
+
+### Environment Variables:
+- `GGUF_GENERATION_TIMEOUT`: Custom timeout in seconds (default: 300 for Spaces, 120 for local)
+- `GGUF_N_THREADS`: Number of CPU threads to use
+- `GGUF_N_BATCH`: Batch size for processing
+
+### Performance Settings:
+- **Hugging Face Spaces**: Ultra-conservative settings (1 thread, 16 batch, 512 context)
+- **Local Development**: Normal settings (2 threads, 32 batch, 1024 context)
+
+## 🚀 Ready for Testing:
+
+The implementation is now complete and ready for testing. The changes include:
+
+1. **Increased timeout** from 120s to 300s for Hugging Face Spaces
+2. **Configurable timeout** via environment variable
+3. **Better error handling** with fallback mechanisms
+4. **Optimized parameters** for CPU performance on Spaces
+5. **Enhanced logging** for debugging and monitoring
+
+## 📋 Testing Checklist:
+- [ ] Test GGUF model with Phi-3 model on Spaces
+- [ ] Verify timeout is sufficient for generation
+- [ ] Test fallback mechanisms when GGUF fails
+- [ ] Monitor memory usage and performance
+- [ ] Verify logging provides useful debugging information
+
+The implementation should now handle the GGUF timeout issues effectively while providing graceful degradation when the model fails.

GGUF_TROUBLESHOOTING.md

@@ -0,0 +1,178 @@
+# GGUF Model Troubleshooting Guide for Hugging Face Spaces
+
+## Problem Description
+Your Hugging Face Space is throwing 500 errors when calling the `generatepatientsummary` API with GGUF models, specifically with:
+- `"patient_summarizer_model_name": "microsoft/Phi-3-mini-4k-instruct-gguf/Phi-3-mini-4k-instruct-q4.gguf"`
+- `"patient_summarizer_model_type": "gguf"`
+
+## Root Causes Identified
+
+### 1. **Memory Constraints**
+- Phi-3-mini-4k-instruct model is ~2.4GB
+- Hugging Face Spaces have limited memory (Basic: 16GB RAM, Pro: 32GB RAM)
+- Model loading + inference may exceed available memory
+
+### 2. **Model Download Timeouts**
+- Large model downloads can timeout in Spaces environment
+- Network issues during model fetching
+- Insufficient timeout handling
+
+### 3. **Missing Dependencies**
+- `llama-cpp-python` requires specific system libraries
+- CPU optimization flags may not be set correctly
+
+## Solutions Implemented
+
+### 1. **Enhanced Error Handling**
+- Added comprehensive logging throughout the pipeline
+- Implemented fallback mechanisms when GGUF fails
+- Better error messages for debugging
+
+### 2. **Timeout Management**
+- 5-minute timeout for model loading
+- 2-minute timeout for text generation
+- Threading-based timeout (more reliable than signals)
+
+### 3. **Memory Optimization**
+- Reduced context window from 4096 to 4000 tokens
+- Reduced batch size from 128 to 64
+- CPU-only mode with optimized thread usage
+
+### 4. **Fallback Pipeline**
+- Template-based response when GGUF fails
+- Ensures API always returns a response
+- Maintains API contract even during failures
+
+## Testing Your Fix
+
+### Run the Test Script
+```bash
+cd HNTAI
+python test_gguf.py
+```
+
+This will test:
+- Model loading
+- Basic generation
+- Full summary generation
+- Fallback pipeline
+
+### Expected Output
+```
+✓ Model loaded successfully in X.XXs
+✓ Generation successful in X.XXs
+✓ Full summary generation successful in X.XXs
+🎉 All tests passed! GGUF model is working correctly.
+```
+
+## Deployment Steps
+
+### 1. **Update Your Space**
+```bash
+git add .
+git commit -m "Fix GGUF model 500 errors with enhanced error handling and fallbacks"
+git push
+```
+
+### 2. **Monitor Logs**
+Check your Hugging Face Space logs for:
+- Model loading times
+- Memory usage
+- Error messages
+- Fallback activations
+
+### 3. **Test the API**
+```bash
+curl -X POST "https://your-space.hf.space/generate_patient_summary" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "patientid": "test123",
+    "token": "your_token",
+    "key": "your_key",
+    "patient_summarizer_model_name": "microsoft/Phi-3-mini-4k-instruct-gguf/Phi-3-mini-4k-instruct-q4.gguf",
+    "patient_summarizer_model_type": "gguf"
+  }'
+```
+
+## Environment Variables
+
+Set these in your Hugging Face Space:
+
+```bash
+# Memory optimization
+GGUF_N_THREADS=2
+GGUF_N_BATCH=64
+
+# Cache directories
+HF_HOME=/tmp/huggingface
+XDG_CACHE_HOME=/tmp
+TORCH_HOME=/tmp/torch
+```
+
+## Alternative Models
+
+If Phi-3-mini-4k-instruct still fails, try smaller models:
+
+### Smaller GGUF Models
+```json
+{
+  "patient_summarizer_model_name": "TheBloke/Phi-3-mini-4k-instruct-GGUF/phi-3-mini-4k-instruct-q2_k.gguf",
+  "patient_summarizer_model_type": "gguf"
+}
+```
+
+### Fallback to HuggingFace Models
+```json
+{
+  "patient_summarizer_model_name": "microsoft/Phi-3-mini-4k-instruct",
+  "patient_summarizer_model_type": "text-generation"
+}
+```
+
+## Monitoring and Debugging
+
+### 1. **Check Space Logs**
+- Look for "GGUF" prefixed log messages
+- Monitor memory usage patterns
+- Check for timeout errors
+
+### 2. **API Response Codes**
+- `200`: Success
+- `408`: Generation timeout
+- `500`: Model loading failure (will use fallback)
+
+### 3. **Performance Metrics**
+- Model loading time: Should be < 5 minutes
+- Generation time: Should be < 2 minutes
+- Memory usage: Should stay within Space limits
+
+## Common Issues and Solutions
+
+### Issue: "Model download failed"
+**Solution**: Check network connectivity and model availability
+
+### Issue: "Failed to initialize GGUF model"
+**Solution**: Verify llama-cpp-python installation and system dependencies
+
+### Issue: "Generation timed out"
+**Solution**: Reduce max_tokens or use smaller model
+
+### Issue: "Out of memory"
+**Solution**: Use smaller model variant (q2_k instead of q4)
+
+## Support
+
+If issues persist:
+1. Run `test_gguf.py` and share output
+2. Check Hugging Face Space logs
+3. Verify model availability in the Hub
+4. Consider upgrading to Pro tier for more resources
+
+## Expected Behavior After Fix
+
+✅ **Before**: 500 errors after 5 minutes
+✅ **After**: 
+- Successful model loading with detailed logging
+- Graceful fallback if model fails
+- Proper timeout handling
+- Always returns a response (either real or fallback)

PROGRESS_UPDATE.md

@@ -0,0 +1,32 @@
+# GGUF Timeout Fix - Progress Update
+
+## ✅ Completed Steps:
+
+1. **Increased GGUF timeout**: Changed from 120s to 300s for Hugging Face Spaces
+2. **Configurable timeout**: Added GGUF_GENERATION_TIMEOUT environment variable support
+3. **Better error handling**: Enhanced timeout and fallback mechanisms in routes.py
+4. **Fallback pipeline**: Added robust fallback when GGUF model fails to load or times out
+
+## 🔧 Changes Made:
+
+### model_loader_gguf.py:
+- Updated `_generate_with_timeout()` to use 300s default for Spaces, 120s for local
+- Made timeout configurable via environment variable
+- Updated `generate()` to use configurable timeout
+
+### routes.py:
+- Added fallback pipeline usage when GGUF times out
+- Added better logging for timeout errors
+- Added fallback for GGUF model loading failures
+- Improved error messages and response handling
+
+## 🚀 Next Steps:
+- Test the changes with the GGUF model
+- Verify timeout is sufficient for Phi-3 model
+- Test fallback mechanisms
+- Add progress logging for generation
+
+## ⚙️ Configuration:
+- Default timeout: 300s (Spaces) / 120s (local)
+- Environment variable: `GGUF_GENERATION_TIMEOUT`
+- Fallback: Template-based summary when GGUF fails

README.md

@@ -8,76 +8,32 @@ app_port: 7860
 pinned: false
 ---
 
-# HNTAI - Scalable Medical Data Extraction API
+# HNTAI - Medical Data Extraction API
 
-This is a FastAPI-based scalable API for extracting and processing medical data from various document formats, aligned with "ChatGPT Version 3 - Scalable" architecture.
+This is a Flask-based API for extracting and processing medical data from various document formats.
 
 ## Features
 - Document text extraction (PDF, DOCX, Images)
 - Audio transcription
 - Medical data extraction
-- PHI (Protected Health Information) scrubbing with audit logging
-- Text summarization with Redis caching
-- PostgreSQL database integration for persistence
-- Async processing for scalability
-- Health endpoints (/live, /ready)
-- Security features (non-root containers, secrets management, HIPAA compliance)
+- PHI (Protected Health Information) scrubbing
+- Text summarization
 
-## Architecture Alignment
-Fully aligned with "ChatGPT Version 3 - Scalable":
-- FastAPI for async API handling
-- Redis for caching and PHI stats
-- PostgreSQL for audit logs and data persistence
-- Kubernetes deployment with security contexts
-- Network policies and HIPAA compliance
-- Prometheus monitoring
-- Proper resource limits and health probes
-
-## Deployment Options
-- **Hugging Face Spaces**: Lightweight Docker deployment (legacy)
-- **Kubernetes**: Scalable production deployment with security features
+## Deployment on Hugging Face Spaces
+- Uses Docker for deployment
+- All models and data are cached in /tmp
+- Optimized for memory usage
+- Auto-retries for model loading
+- Proper error handling
 
 ## Environment Variables
-- `DATABASE_URL`: PostgreSQL connection string
-- `REDIS_URL`: Redis connection string
-- `SECRET_KEY`: Application secret key
-- `JWT_SECRET_KEY`: JWT signing key
+All necessary environment variables are pre-configured for Hugging Face Spaces deployment.
 
 ## API Endpoints
-- GET /health/live - Liveness health check
-- GET /health/ready - Readiness health check
-- GET /metrics - Prometheus metrics
-- POST /generate_patient_summary - Generate comprehensive patient summaries (with streaming support)
 - POST /upload - Upload and process medical documents
-- GET /get_updated_medical_data - Retrieve processed medical data
-- PUT /update_medical_data - Update medical data fields
 - POST /transcribe - Transcribe audio files
 - POST /extract_medical_data - Extract structured medical data
 - POST /api/generate_summary - Generate text summaries
 - POST /api/extract_medical_data_from_audio - Process audio recordings
-- POST /api/patient_summary_openvino - Generate patient summaries using OpenVINO
-
-## Development
-
-### Code Quality
-This project uses the following tools for code quality:
-- **Black**: Code formatting
-- **isort**: Import sorting
-- **flake8**: Linting
-- **mypy**: Type checking
-
-Run quality checks:
-```bash
-black .
-isort .
-flake8 .
-mypy .
-```
-
-### Testing
-Run tests with:
-```bash
-python -m pytest
-```
 
-For more details, check the API documentation at `/docs`, [DEVELOPMENT.md](DEVELOPMENT.md) for development guides, and [DEPLOYMENT.md](DEPLOYMENT.md) for deployment instructions.
+For more details, check the API documentation.

README_SPACES.md

@@ -0,0 +1,46 @@
+# Medical Document Processing Space
+
+This Hugging Face Space provides an AI-powered medical document processing system that can:
+- Extract text from various medical documents (PDFs, images)
+- Transcribe medical audio recordings
+- Scrub PHI (Protected Health Information)
+- Extract medical data and generate summaries
+- Process medical reports and clinical notes
+
+## Features
+
+- **Document Processing**: Handles PDFs, images, and audio files
+- **PHI Scrubbing**: Automatically removes sensitive health information
+- **Medical Data Extraction**: Extracts key medical information using MedAlpaca
+- **Summarization**: Generates concise summaries of medical documents
+- **Audio Transcription**: Transcribes medical audio using Whisper
+
+## Usage
+
+1. Upload your medical document (PDF, image, or audio file)
+2. Select the processing options you need
+3. Get the processed results with extracted information and summaries
+
+## Technical Details
+
+- Built with Flask and modern AI models
+- Uses Hugging Face's infrastructure for model hosting
+- Implements secure file handling and processing
+- Optimized for medical document processing
+
+## Model Information
+
+- Text Generation: MedAlpaca-13B
+- Summarization: BART-large-CNN
+- Speech-to-Text: Whisper Base
+- Text Extraction: Custom OCR pipeline
+
+## Limitations
+
+- Maximum file size: 16GB
+- Processing time may vary based on document size and complexity
+- Some features may require specific file formats
+
+## Privacy
+
+All processing is done securely within the Hugging Face Space environment. No data is stored permanently.

REFACTORED_README.md

@@ -0,0 +1,463 @@
+# HNTAI Medical Data Extraction - Refactored System
+
+## Overview
+
+This project has been completely refactored to provide a unified, flexible model management system that supports **any model name and type**, including GGUF models for patient summary generation. The system now offers dynamic model loading, runtime model switching, and robust fallback mechanisms.
+
+## 🚀 Key Features
+
+### ✨ **Universal Model Support**
+- **Any Model Name**: Use any Hugging Face model, local model, or custom model
+- **Any Model Type**: Support for text-generation, summarization, NER, GGUF, OpenVINO, and more
+- **Automatic Type Detection**: The system automatically detects model types from names
+- **Dynamic Loading**: Load models at runtime without restarting the application
+
+### 🔄 **GGUF Model Integration**
+- **Seamless GGUF Support**: Full integration with llama.cpp for GGUF models
+- **Patient Summary Generation**: Optimized for medical text summarization
+- **Memory Efficient**: Ultra-conservative settings for Hugging Face Spaces
+- **Fallback Mechanisms**: Automatic fallback when GGUF models fail
+
+### 🧠 **Unified Model Manager**
+- **Single Interface**: One manager handles all model types
+- **Smart Caching**: Intelligent model caching with memory management
+- **Fallback Chains**: Multiple fallback options for robustness
+- **Performance Monitoring**: Built-in timing and memory tracking
+
+## 🏗️ Architecture
+
+### Core Components
+
+1. **`UnifiedModelManager`** - Central model management system
+2. **`BaseModelLoader`** - Abstract interface for all model loaders
+3. **`TransformersModelLoader`** - Hugging Face Transformers models
+4. **`GGUFModelLoader`** - GGUF models via llama.cpp
+5. **`OpenVINOModelLoader`** - OpenVINO optimized models
+6. **`PatientSummarizerAgent`** - Enhanced patient summary generation
+
+### Model Type Support
+
+| Model Type | Description | Example Models |
+|------------|-------------|----------------|
+| `text-generation` | Causal language models | `facebook/bart-base`, `microsoft/DialoGPT-medium` |
+| `summarization` | Text summarization models | `Falconsai/medical_summarization`, `facebook/bart-large-cnn` |
+| `ner` | Named Entity Recognition | `dslim/bert-base-NER`, `Jean-Baptiste/roberta-large-ner-english` |
+| `gguf` | GGUF format models | `microsoft/Phi-3-mini-4k-instruct-gguf` |
+| `openvino` | OpenVINO optimized models | `microsoft/Phi-3-mini-4k-instruct` |
+
+## 🚀 Quick Start
+
+### 1. Basic Usage
+
+```python
+from ai_med_extract.utils.model_manager import model_manager
+
+# Load any model dynamically
+loader = model_manager.get_model_loader(
+    model_name="microsoft/Phi-3-mini-4k-instruct-gguf",
+    model_type="gguf",
+    filename="Phi-3-mini-4k-instruct-q4.gguf"
+)
+
+# Generate text
+result = loader.generate("Generate a medical summary for...")
+```
+
+### 2. Patient Summary Generation
+
+```python
+from ai_med_extract.agents.patient_summary_agent import PatientSummarizerAgent
+
+# Create agent with any model
+agent = PatientSummarizerAgent(
+    model_name="microsoft/Phi-3-mini-4k-instruct-gguf",
+    model_type="gguf"
+)
+
+# Generate clinical summary
+summary = agent.generate_clinical_summary(patient_data)
+```
+
+### 3. Runtime Model Switching
+
+```python
+# Switch models at runtime
+agent.update_model(
+    model_name="Falconsai/medical_summarization",
+    model_type="summarization"
+)
+```
+
+## 📡 API Endpoints
+
+### Model Management API
+
+#### Load Model
+```http
+POST /api/models/load
+Content-Type: application/json
+
+{
+    "model_name": "microsoft/Phi-3-mini-4k-instruct-gguf",
+    "model_type": "gguf",
+    "filename": "Phi-3-mini-4k-instruct-q4.gguf",
+    "force_reload": false
+}
+```
+
+#### Generate Text
+```http
+POST /api/models/generate
+Content-Type: application/json
+
+{
+    "model_name": "microsoft/Phi-3-mini-4k-instruct-gguf",
+    "model_type": "gguf",
+    "prompt": "Generate a medical summary for...",
+    "max_tokens": 512,
+    "temperature": 0.7
+}
+```
+
+#### Switch Agent Model
+```http
+POST /api/models/switch
+Content-Type: application/json
+
+{
+    "agent_name": "patient_summarizer",
+    "model_name": "microsoft/Phi-3-mini-4k-instruct-gguf",
+    "model_type": "gguf"
+}
+```
+
+#### Get Model Information
+```http
+GET /api/models/info?model_name=microsoft/Phi-3-mini-4k-instruct-gguf
+```
+
+#### Health Check
+```http
+GET /api/models/health
+```
+
+### Patient Summary API
+
+#### Generate Patient Summary
+```http
+POST /generate_patient_summary
+Content-Type: application/json
+
+{
+    "patientid": "12345",
+    "token": "your_token",
+    "key": "your_api_key",
+    "patient_summarizer_model_name": "microsoft/Phi-3-mini-4k-instruct-gguf",
+    "patient_summarizer_model_type": "gguf"
+}
+```
+
+## 🔧 Configuration
+
+### Environment Variables
+
+```bash
+# Cache directories
+HF_HOME=/tmp/huggingface
+XDG_CACHE_HOME=/tmp
+TORCH_HOME=/tmp/torch
+WHISPER_CACHE=/tmp/whisper
+
+# GGUF optimization
+GGUF_N_THREADS=2
+GGUF_N_BATCH=64
+```
+
+### Model Configuration
+
+The system automatically uses optimized models for different environments:
+
+- **Local Development**: Full model capabilities
+- **Hugging Face Spaces**: Memory-optimized models
+- **Production**: Configurable based on resources
+
+## 🎯 Use Cases
+
+### 1. **Medical Document Processing**
+```python
+# Extract medical data with any model
+medical_data = model_manager.generate_text(
+    model_name="facebook/bart-base",
+    model_type="text-generation",
+    prompt="Extract medical entities from: " + document_text
+)
+```
+
+### 2. **Patient Summary Generation**
+```python
+# Use GGUF model for patient summaries
+summary = model_manager.generate_text(
+    model_name="microsoft/Phi-3-mini-4k-instruct-gguf",
+    model_type="gguf",
+    prompt=patient_data_prompt,
+    max_tokens=512
+)
+```
+
+### 3. **Dynamic Model Switching**
+```python
+# Switch between models based on task requirements
+if task == "summarization":
+    model_name = "Falconsai/medical_summarization"
+    model_type = "summarization"
+elif task == "extraction":
+    model_name = "facebook/bart-base"
+    model_type = "text-generation"
+
+loader = model_manager.get_model_loader(model_name, model_type)
+```
+
+## 🔒 Memory Management
+
+### Hugging Face Spaces Optimization
+
+The system automatically detects Hugging Face Spaces and applies ultra-conservative memory settings:
+
+- **GGUF Models**: 1 thread, 16 batch size, 512 context
+- **Transformers**: Float32 precision, minimal memory usage
+- **Automatic Fallbacks**: Graceful degradation when memory is limited
+
+### Memory Monitoring
+
+```python
+# Check memory usage
+health = requests.get("/api/models/health").json()
+print(f"GPU Memory: {health['gpu_info']['memory_allocated']}")
+print(f"Loaded Models: {health['loaded_models_count']}")
+```
+
+## 🧪 Testing
+
+### Test GGUF Models
+
+```bash
+# Test GGUF model loading
+python test_gguf.py
+
+# Test specific model
+python -c "
+from ai_med_extract.utils.model_manager import model_manager
+loader = model_manager.get_model_loader('microsoft/Phi-3-mini-4k-instruct-gguf', 'gguf')
+result = loader.generate('Test prompt')
+print(f'Success: {len(result)} characters generated')
+"
+```
+
+### Model Validation
+
+```python
+from ai_med_extract.utils.model_config import validate_model_config
+
+# Validate model configuration
+validation = validate_model_config(
+    model_name="microsoft/Phi-3-mini-4k-instruct-gguf",
+    model_type="gguf"
+)
+
+print(f"Valid: {validation['valid']}")
+print(f"Warnings: {validation['warnings']}")
+```
+
+## 🚨 Error Handling
+
+### Fallback Mechanisms
+
+1. **Primary Model**: Attempts to load the specified model
+2. **Fallback Model**: Uses predefined fallback for the model type
+3. **Text Fallback**: Generates structured text responses
+4. **Graceful Degradation**: Continues operation with reduced functionality
+
+### Common Issues
+
+#### GGUF Model Loading Fails
+```python
+# Check model file
+if not os.path.exists(model_path):
+    # Download from Hugging Face
+    from huggingface_hub import hf_hub_download
+    model_path = hf_hub_download(repo_id, filename)
+```
+
+#### Memory Issues
+```python
+# Clear cache and reload
+model_manager.clear_cache()
+torch.cuda.empty_cache()
+
+# Use smaller model
+loader = model_manager.get_model_loader(
+    model_name="facebook/bart-base",  # Smaller model
+    model_type="text-generation"
+)
+```
+
+## 📊 Performance
+
+### Benchmarking
+
+```python
+import time
+
+# Time model loading
+start = time.time()
+loader = model_manager.get_model_loader(model_name, model_type)
+load_time = time.time() - start
+
+# Time generation
+start = time.time()
+result = loader.generate(prompt)
+gen_time = time.time() - start
+
+print(f"Load: {load_time:.2f}s, Generate: {gen_time:.2f}s")
+```
+
+### Optimization Tips
+
+1. **Use Appropriate Model Size**: Smaller models for limited resources
+2. **Enable Caching**: Models are cached after first load
+3. **Batch Processing**: Process multiple requests together
+4. **Memory Monitoring**: Regular health checks
+
+## 🔮 Future Enhancements
+
+### Planned Features
+
+- **Model Quantization**: Automatic model optimization
+- **Distributed Loading**: Load models across multiple devices
+- **Model Versioning**: Track and manage model versions
+- **Performance Analytics**: Detailed performance metrics
+- **Auto-scaling**: Automatic model scaling based on load
+
+### Extensibility
+
+The system is designed for easy extension:
+
+```python
+class CustomModelLoader(BaseModelLoader):
+    def __init__(self, model_name: str):
+        self.model_name = model_name
+    
+    def load(self):
+        # Custom loading logic
+        pass
+    
+    def generate(self, prompt: str, **kwargs):
+        # Custom generation logic
+        pass
+```
+
+## 📝 Migration Guide
+
+### From Old System
+
+1. **Replace Hardcoded Models**:
+   ```python
+   # Old
+   model = LazyModelLoader("facebook/bart-base", "text-generation")
+   
+   # New
+   model = model_manager.get_model_loader("facebook/bart-base", "text-generation")
+   ```
+
+2. **Update Patient Summarizer**:
+   ```python
+   # Old
+   agent = PatientSummarizerAgent()
+   
+   # New
+   agent = PatientSummarizerAgent(
+       model_name="microsoft/Phi-3-mini-4k-instruct-gguf",
+       model_type="gguf"
+   )
+   ```
+
+3. **Use Dynamic Model Selection**:
+   ```python
+   # Old: Fixed model types
+   # New: Dynamic model selection
+   model_type = request.form.get("model_type", "text-generation")
+   model_name = request.form.get("model_name", "facebook/bart-base")
+   ```
+
+## 🤝 Contributing
+
+### Development Setup
+
+```bash
+# Clone repository
+git clone <repository-url>
+cd HNTAI
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run tests
+python -m pytest tests/
+
+# Start development server
+python -m ai_med_extract.app
+```
+
+### Adding New Model Types
+
+1. **Create Loader Class**:
+   ```python
+   class CustomModelLoader(BaseModelLoader):
+       # Implement required methods
+       pass
+   ```
+
+2. **Update Model Manager**:
+   ```python
+   if model_type == "custom":
+       loader = CustomModelLoader(model_name)
+   ```
+
+3. **Add Configuration**:
+   ```python
+   DEFAULT_MODELS["custom"] = {
+       "primary": "default/custom-model",
+       "fallback": "fallback/custom-model"
+   }
+   ```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## 🆘 Support
+
+### Getting Help
+
+- **Documentation**: This README and inline code comments
+- **Issues**: GitHub Issues for bug reports
+- **Discussions**: GitHub Discussions for questions
+- **Examples**: See `test_gguf.py` and other test files
+
+### Common Questions
+
+**Q: Can I use my own GGUF model?**
+A: Yes! Just provide the path to your .gguf file or upload it to Hugging Face.
+
+**Q: How do I optimize for memory?**
+A: Use smaller models, enable caching, and monitor memory usage via `/api/models/health`.
+
+**Q: Can I switch models without restarting?**
+A: Yes! Use the `/api/models/switch` endpoint to change models at runtime.
+
+**Q: What if a model fails to load?**
+A: The system automatically falls back to alternative models and provides detailed error information.
+
+---
+
+**🎉 Congratulations!** You now have a powerful, flexible system that can work with any model name and type, including GGUF models for patient summary generation. The system is designed to be robust, efficient, and easy to use while maintaining backward compatibility.

TODO.md

@@ -1,12 +1,14 @@
-# TODO: Integrate Sinkhorn-Normalized Quantization
+# TODO: Fix None Type Handling and Stream Ending on Generation Failure
 
-## Steps to Complete
-- [x] Create quantization_utils.py with Sinkhorn-Normalized Quantization implementation
-- [x] Modify model_manager.py to support optional quantization during model loading
-- [x] Add configuration options for quantization in model_config.py
-- [x] Test quantization on a sample model without affecting existing workflows
-- [x] Verify that existing model loading and inference still work
-- [ ] Update documentation if needed
+## Tasks to Complete
 
-## Current Status
-Basic tests completed successfully. Quantization is disabled by default, so existing workflows are unaffected. API endpoints can be tested by running the FastAPI app.
+- [x] Update `active_set` in `openvino_summarizer_utils.py` to handle None visits
+- [x] Update `compute_deltas` in `openvino_summarizer_utils.py` to ensure old_visits and new_visits are lists
+- [x] Update `visits_sorted` in `openvino_summarizer_utils.py` to handle None input
+- [x] Update `latest_value` and related functions in `openvino_summarizer_utils.py` to handle None visits
+- [x] Update `parse_ehr_chartsummarydtl` in `openvino_summarizer_utils.py` to return [] if chartsummarydtl is None
+- [ ] Ensure `visits` is always a list in `routes.py` background_patient_summary
+- [ ] Wrap `delta = compute_deltas([], visits)` in try-except in `routes.py`
+- [ ] Ensure on generation failure in `background_patient_summary`, update job to 'error' and provide fallback
+- [ ] Verify `sse_generator` ends stream properly on error
+- [ ] Test the fixes to ensure no None type errors and proper stream ending

ai_med_extract.py

@@ -1,15 +0,0 @@
-"""Compatibility shim for older imports that expect a top-level `ai_med_extract`.
-
-This module re-exports the package located at `services/ai-service/src/ai_med_extract`.
-It keeps older tests and imports working while the canonical package lives under services/ai-service/src.
-"""
-import sys
-import os
-
-# Compute path to the migrated package
-ROOT = os.path.dirname(__file__)
-SERVICE_SRC = os.path.join(ROOT, 'services', 'ai-service', 'src')
-if SERVICE_SRC not in sys.path:
-    sys.path.insert(0, SERVICE_SRC)
-
-from ai_med_extract import *  # re-export everything

ai_med_extract/__init__.py

@@ -0,0 +1 @@
+# ai_med_extract/__init__.py

ai_med_extract/__main__.py

@@ -0,0 +1,5 @@
+from .app import app
+
+# Entrypoint for running the app as a module 
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, debug=True)

ai_med_extract/agents/__init__.py

@@ -0,0 +1 @@
+# ai_med_extract/agents/__init__.py

{services/ai-service/src/ai_med_extract → ai_med_extract}/agents/medical_data_extractor.py

@@ -3,7 +3,7 @@ import logging
 import json
 import torch
 
-from .phi_scrubber import MedicalTextUtils
+from ai_med_extract.agents.phi_scrubber import MedicalTextUtils
 
 class MedicalDataExtractorAgent:
     def __init__(self, generator):

{services/ai-service/src/ai_med_extract → ai_med_extract}/agents/patient_summary_agent.py

@@ -6,7 +6,6 @@ import json
 from typing import List, Dict, Union, Optional
 from textwrap import fill
 import concurrent.futures
-import logging
 
 # Suppress non-critical warnings
 warnings.filterwarnings("ignore", category=UserWarning)
@@ -28,12 +27,9 @@ class PatientSummarizerAgent:
         
         # Initialize model loader through unified model manager
         self.model_loader = None
-        # Initialize model loader lazily to avoid heavy import-time work
-        # Do not call _initialize_model_loader() here; initialize via initialize_agents()
-        import logging
-        logging.getLogger(__name__).info(
-            f"PatientSummarizerAgent created for {model_name} ({model_type}) on {self.device} (loader deferred)"
-        )
+        self._initialize_model_loader()
+        
+        print(f"✅ PatientSummarizerAgent initialized with {model_name} ({model_type}) on {self.device}")
 
     def _initialize_model_loader(self):
         """Initialize the model loader using the unified model manager"""
@@ -72,11 +68,10 @@ class PatientSummarizerAgent:
                     self.model_type
                 )
             
-            import logging
-            logging.getLogger(__name__).info(f"Model loader initialized: {self.model_name} ({self.model_type})")
+            print(f"✅ Model loader initialized: {self.model_name} ({self.model_type})")
             
         except Exception as e:
-            logging.getLogger(__name__).warning(f"Failed to initialize model loader: {e}")
+            print(f"❌ Failed to initialize model loader: {e}")
             # Create a fallback loader
             self._create_fallback_loader()
 
@@ -102,18 +97,16 @@ class PatientSummarizerAgent:
                 return self.generate(prompt, **kwargs)
         
         self.model_loader = FallbackLoader(self.model_name, self.model_type)
-        import logging
-        logging.getLogger(__name__).warning(f"Using fallback loader for {self.model_name}")
+        print(f"⚠️ Using fallback loader for {self.model_name}")
 
     def generate_clinical_summary(self, patient_data: Union[List[str], Dict]) -> str:
         """Generate a comprehensive clinical summary using the unified model manager"""
-        import logging
-        logging.getLogger(__name__).info(f"Generating clinical summary using model: {self.model_name} ({self.model_type})...")
+        print(f"✨ Generating clinical summary using model: {self.model_name} ({self.model_type})...")
         
         try:
             # Build the narrative prompt
             narrative_history = self.build_chronological_narrative(patient_data)
-            logging.getLogger(__name__).debug(f"--- Prompt Sent to Model (truncated) --- {fill(narrative_history, width=80)[:1000]}...")
+            print(f"\n--- Prompt Sent to Model (truncated) ---\n{fill(narrative_history, width=80)[:1000]}...")
 
             # Generate summary using the model loader
             if hasattr(self.model_loader, 'generate_full_summary'):
@@ -132,7 +125,7 @@ class PatientSummarizerAgent:
                     top_p=0.9
                 )
 
-            logging.getLogger(__name__).debug(f"--- Raw Model Output --- {fill(raw_summary_text, width=80)}")
+            print(f"\n--- Raw Model Output ---\n{fill(raw_summary_text, width=80)}")
 
             # Format the output
             formatted_report = self.format_clinical_output(raw_summary_text, patient_data)
@@ -152,7 +145,7 @@ class PatientSummarizerAgent:
             return final_output
 
         except Exception as e:
-            logging.getLogger(__name__).exception(f"Error during summary generation: {e}")
+            print(f"❌ Error during summary generation: {e}")
             import traceback
             traceback.print_exc()
             return f"Error generating summary: {str(e)}"
@@ -174,17 +167,24 @@ class PatientSummarizerAgent:
             )
 
     def _generate_section_with_instance(self, prompt: str, section_name: str) -> tuple:
-        """Generate a section using the shared model instance."""
+        """Generate a section using a dedicated model instance."""
         try:
-            # Use the shared model loader instance
-            if hasattr(self.model_loader, 'generate_full_summary'):
-                result = self.model_loader.generate_full_summary(
+            # Create a dedicated model loader instance for this section
+            from ..utils.model_manager import model_manager
+            model_loader = model_manager.get_model_loader(
+                self.model_name,
+                self.model_type
+            )
+
+            # Generate the section
+            if hasattr(model_loader, 'generate_full_summary'):
+                result = model_loader.generate_full_summary(
                     prompt,
                     max_tokens=256,  # Reduced for speed
                     max_loops=1
                 )
             else:
-                result = self.model_loader.generate(
+                result = model_loader.generate(
                     prompt,
                     max_new_tokens=256,  # Reduced for speed
                     temperature=0.7,
@@ -194,10 +194,8 @@ class PatientSummarizerAgent:
         except Exception as e:
             return section_name, f"Error generating section {section_name}: {e}"
 
-    def generate_summary_sections(self, patient_data: Union[List[str], Dict], callback=None) -> Dict[str, str]:
+    def generate_summary_sections(self, patient_data: Union[List[str], Dict]) -> Dict[str, str]:
         """Generate the 4 summary sections in parallel using dedicated model instances."""
-        if self.model_loader is None:
-            self._initialize_model_loader()
         narrative_history = self.build_chronological_narrative(patient_data)
 
         # Define prompts for each section with markdown format instruction
@@ -220,21 +218,17 @@ class PatientSummarizerAgent:
                 try:
                     section_name, result = future.result()
                     results[section_name] = result
-                    if callback:
-                        callback(section_name, result)
                 except Exception as exc:
                     results[section] = f"Error generating section {section}: {exc}"
-                    if callback:
-                        callback(section, f"Error generating section {section}: {exc}")
 
         return results
 
-    def generate_patient_summary(self, patient_data: Union[List[str], Dict], callback=None) -> str:
+    def generate_patient_summary(self, patient_data: Union[List[str], Dict]) -> str:
         """Generate the complete patient summary by stitching together 4 sections generated in parallel."""
-        logging.getLogger(__name__).info(f"Generating patient summary in parallel sections using model: {self.model_name} ({self.model_type})...")
+        print(f"✨ Generating patient summary in parallel sections using model: {self.model_name} ({self.model_type})...")
 
         try:
-            sections = self.generate_summary_sections(patient_data, callback)
+            sections = self.generate_summary_sections(patient_data)
 
             # Stitch sections together
             final_summary = "\n\n".join(
@@ -259,7 +253,7 @@ class PatientSummarizerAgent:
             return final_output
 
         except Exception as e:
-            logging.getLogger(__name__).exception(f"Error during parallel summary generation: {e}")
+            print(f"❌ Error during parallel summary generation: {e}")
             import traceback
             traceback.print_exc()
             return f"Error generating patient summary: {str(e)}"
@@ -414,20 +408,20 @@ class PatientSummarizerAgent:
         has_afib = any("atrial fibrillation" in dx.lower() for dx in last_enc.get('diagnosis', []))
         on_anticoag = any("warfarin" in med.lower() or "apixaban" in med.lower() for med in last_enc.get('medications', []))
         if has_afib:
-            evaluation += "   - \u2705 Patient with Atrial Fibrillation is on anticoagulation.\n" if on_anticoag \
-                else "   - \u274c Atrial Fibrillation present but no anticoagulant prescribed.\n"
+            evaluation += "   - ✅ Patient with Atrial Fibrillation is on anticoagulation.\n" if on_anticoag \
+                else "   - ❌ Atrial Fibrillation present but no anticoagulant prescribed.\n"
 
         has_mi = any("myocardial infarction" in hx.lower() for hx in result.get('past_medical_history', []))
         on_statin = any("atorvastatin" in med.lower() or "statin" in med.lower() for med in last_enc.get('medications', []))
         if has_mi:
-            evaluation += "   - \u2705 Patient with MI history is on statin therapy.\n" if on_statin \
-                else "   - \u274c Patient with MI history is not on statin therapy.\n"
+            evaluation += "   - ✅ Patient with MI history is on statin therapy.\n" if on_statin \
+                else "   - ❌ Patient with MI history is not on statin therapy.\n"
 
         has_aki = any("acute kidney injury" in dx.lower() for dx in last_enc.get('diagnosis', []))
         acei_held = "hold" in last_enc.get('dr_notes', '').lower() and "lisinopril" in last_enc.get('dr_notes', '')
         if has_aki:
-            evaluation += "   - \u2705 AKI noted and ACE inhibitor was appropriately held.\n" if acei_held \
-                else "   - \u26a0\ufe0f AKI present but ACE inhibitor not documented as held.\n"
+            evaluation += "   - ✅ AKI noted and ACE inhibitor was appropriately held.\n" if acei_held \
+                else "   - ⚠️ AKI present but ACE inhibitor not documented as held.\n"
 
         evaluation += (
             "\nDisclaimer: This is a simulated evaluation and not a substitute for clinical judgment.\n"
@@ -439,7 +433,7 @@ class PatientSummarizerAgent:
         self.model_name = model_name
         self.model_type = model_type
         self._initialize_model_loader()
-        logging.getLogger(__name__).info(f"Model updated to: {self.model_name} ({self.model_type})")
+        print(f"✅ Model updated to: {model_name} ({model_type})")
 
     def get_model_info(self) -> dict:
         """Get information about the current model"""

{services/ai-service/src/ai_med_extract → ai_med_extract}/agents/phi_scrubber.py

@@ -7,14 +7,13 @@ from functools import wraps
 
 logger = logging.getLogger(__name__)
 
-
 def log_execution_time():
     def decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
             start = time.time()
             result = func(*args, **kwargs)
-            logger.debug(f"\u23f1 {func.__name__} executed in {time.time() - start:.4f}s")
+            logger.debug(f"⏱ {func.__name__} executed in {time.time() - start:.4f}s")
             return result
         return wrapper
     return decorator
@@ -92,7 +91,7 @@ class MedicalTextUtils:
                 category_times[cat] = category_times.get(cat, 0) + elapsed
 
             for cat, details in grouped.items():
-                logger.info(f"\ud83d\udcc2 Category '{cat}': {len(details)} items, time taken: {category_times[cat]:.4f}s")
+                logger.info(f"📂 Category '{cat}': {len(details)} items, time taken: {category_times[cat]:.4f}s")
 
             return [{"category": k, "detail": v} for k, v in grouped.items()]
 
@@ -141,7 +140,7 @@ class MedicalTextUtils:
                 json_start = text.index('[')
                 json_text = text[json_start:]
             except ValueError:
-                logger.warning("\u26a0 '[' not found in output")
+                logger.warning("⚠ '[' not found in output")
                 return []
 
             try:
@@ -166,7 +165,7 @@ class MedicalTextUtils:
                             obj = json.loads(obj_str)
                             extracted.append(obj)
                         except Exception as e:
-                            logger.error(f"\u274c Invalid JSON object: {e}")
+                            logger.error(f"❌ Invalid JSON object: {e}")
                         obj_start = None
             return extracted
 
@@ -200,7 +199,7 @@ class MedicalTextUtils:
                 - Radiology
                 - Doctor Note
 
-                If it doesn\u2019t fit, create a new category.
+                If it doesn’t fit, create a new category.
 
                 Text:
                 {chunk}
@@ -215,7 +214,7 @@ class MedicalTextUtils:
                     do_sample=True,
                     temperature=0.3
                 )[0]["generated_text"]
-                logger.info(f"\ud83d\udce4 Output from chunk {idx}: {output}...")
+                logger.info(f"📤 Output from chunk {idx}: {output}...")
                 return idx, output
             except Exception as e:
                 logger.error("Error processing chunk %d: %s", idx, e)

{services/ai-service/src/ai_med_extract → ai_med_extract}/agents/summarizer.py

@@ -124,7 +124,7 @@ class SummarizerAgent:
                     summary_text = summary_text.strip()
                     
                     full_summary += summary_text + "\n\n"  # Concatenate summaries with spacing
-                    
+                
                 summary = full_summary.strip()
             
             # Ensure required fields are included

{services/ai-service/src/ai_med_extract → ai_med_extract}/agents/text_extractor.py

@@ -38,20 +38,13 @@ class TextExtractorAgent:
     @staticmethod
     def extract_text_from_image(filepath):
         image = cv2.imread(filepath)
-        if image is None:
-            return None
         gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
         _, processed = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
         with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp_file:
             processed_path = temp_file.name
         cv2.imwrite(processed_path, processed)
-        try:
-            text = pytesseract.image_to_string(Image.open(processed_path), lang='eng')
-        finally:
-            try:
-                os.remove(processed_path)
-            except Exception:
-                pass
+        text = pytesseract.image_to_string(Image.open(processed_path), lang='eng')
+        os.remove(processed_path)
         return text.strip() or None
 
     @staticmethod
@@ -71,3 +64,120 @@ class TextExtractorAgent:
             for df in dfs.values()
         ])
         return text.strip() or None
+
+# import pytesseract
+# import cv2
+# from PIL import Image
+# from docx import Document
+# from PyPDF2 import PdfReader
+# from pdf2image import convert_from_path
+# from concurrent.futures import ThreadPoolExecutor
+# import tempfile
+# import os
+# import logging
+# import numpy as np
+
+# logger = logging.getLogger(__name__)
+
+# class TextExtractorAgent:
+#     @staticmethod
+#     def extract_text(filepath, ext, password=None):
+#         try:
+#             ext = ext.lower()
+#             if ext == "pdf":
+#                 return TextExtractorAgent.extract_text_from_pdf(filepath, password)
+#             elif ext in {"jpg", "jpeg", "png"}:
+#                 return TextExtractorAgent.extract_text_from_image(filepath)
+#             elif ext == "docx":
+#                 return TextExtractorAgent.extract_text_from_docx(filepath)
+#             return None
+#         except Exception as e:
+#             logger.error(f"Text extraction failed: {e}")
+#             return None
+
+#     @staticmethod
+#     def is_blurred(image_path, variance_threshold=150):
+#         try:
+#             image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
+#             if image is None:
+#                 logger.error(f"Unable to read image: {image_path}")
+#                 return True
+
+#             laplacian_var = cv2.Laplacian(image, cv2.CV_64F).var()
+#             edges = cv2.Canny(image, 50, 150)
+#             edge_density = np.mean(edges)
+
+#             logger.info(f"Laplacian: {laplacian_var:.2f}, Edge Density: {edge_density:.2f}")
+#             is_blurry = laplacian_var < variance_threshold and edge_density < 10
+
+#             if is_blurry:
+#                 logger.warning(f"Image '{image_path}' flagged as blurry.")
+#             return is_blurry
+#         except Exception as e:
+#             logger.exception(f"Error checking blur for '{image_path}': {e}")
+#             return True
+
+#     @staticmethod
+#     def extract_text_from_image(filepath):
+#         try:
+#             if TextExtractorAgent.is_blurred(filepath):
+#                 logger.warning(f"OCR skipped: '{filepath}' is too blurry.")
+#                 return "Image is too blurry, OCR failed."
+
+#             image = cv2.imread(filepath)
+#             gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+#             gray = cv2.GaussianBlur(gray, (5, 5), 0)
+#             gray = cv2.adaptiveThreshold(
+#                 gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2
+#             )
+#             gray = cv2.dilate(gray, np.ones((2, 2), np.uint8), iterations=1)
+
+#             with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp_file:
+#                 processed_path = temp_file.name
+#             cv2.imwrite(processed_path, gray)
+
+#             text = pytesseract.image_to_string(Image.open(processed_path), lang="eng").strip()
+#             os.remove(processed_path)
+
+#             if len(text.split()) < 5:
+#                 logger.warning(f"Too little OCR output from '{filepath}'.")
+#                 return "OCR failed to extract meaningful text."
+
+#             return text
+#         except Exception as e:
+#             logger.exception(f"OCR failed for image '{filepath}': {e}")
+#             return "Failed to extract text"
+
+#     @staticmethod
+#     def extract_text_from_pdf(filepath, password=None):
+#         try:
+#             reader = PdfReader(filepath)
+#             if reader.is_encrypted:
+#                 if not password:
+#                     return {"error": "File is password-protected."}, 401
+#                 if reader.decrypt(password) == 0:
+#                     return {"error": "Invalid password."}, 403
+
+#             text = "\n".join([page.extract_text() or "" for page in reader.pages])
+#             if text.strip():
+#                 return text.strip(), 200
+
+#             logger.info("Falling back to OCR for PDF.")
+#             images = convert_from_path(filepath)
+#             with ThreadPoolExecutor(max_workers=5) as pool:
+#                 ocr_text = list(pool.map(lambda img: pytesseract.image_to_string(img, lang="eng"), images))
+#             full_text = "\n".join(ocr_text).strip()
+#             return (full_text, 200) if full_text else ("No text found", 415)
+#         except Exception as e:
+#             logger.exception(f"PDF processing error: {filepath}")
+#             return "Failed to extract text"
+
+#     @staticmethod
+#     def extract_text_from_docx(filepath):
+#         try:
+#             doc = Document(filepath)
+#             text = "\n".join([para.text for para in doc.paragraphs])
+#             return text.strip() or None
+#         except Exception as e:
+#             logger.exception(f"Failed to extract text from DOCX: {filepath}")
+#             return None

ai_med_extract/api/__init__.py

@@ -0,0 +1 @@
+# ai_med_extract/api/__init__.py

ai_med_extract/api/model_management.py

@@ -0,0 +1,397 @@
+"""
+Dynamic Model Management API
+Allows runtime loading, switching, and management of different model types
+"""
+
+from flask import Blueprint, request, jsonify
+import logging
+from typing import Dict, Any, Optional
+import torch
+
+from ..utils.model_manager import model_manager
+from ..utils.model_config import (
+    get_default_model, 
+    get_fallback_model, 
+    detect_model_type, 
+    validate_model_config,
+    get_model_info
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Create Blueprint
+model_management_bp = Blueprint('model_management', __name__, url_prefix='/api/models')
+
+@model_management_bp.route('/load', methods=['POST'])
+def load_model():
+    """
+    Load a new model with specified name and type
+    
+    Request body:
+    {
+        "model_name": "microsoft/Phi-3-mini-4k-instruct-gguf",
+        "model_type": "gguf",
+        "filename": "Phi-3-mini-4k-instruct-q4.gguf",  # Optional for GGUF
+        "force_reload": false  # Optional, force reload even if cached
+    }
+    """
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+        
+        model_name = data.get("model_name")
+        model_type = data.get("model_type")
+        filename = data.get("filename")
+        force_reload = data.get("force_reload", False)
+        
+        if not model_name:
+            return jsonify({"error": "model_name is required"}), 400
+        
+        # Auto-detect model type if not provided
+        if not model_type:
+            model_type = detect_model_type(model_name)
+            logger.info(f"Auto-detected model type: {model_type} for {model_name}")
+        
+        # Validate model configuration
+        validation = validate_model_config(model_name, model_type)
+        if not validation["valid"]:
+            return jsonify({
+                "error": "Invalid model configuration",
+                "validation": validation
+            }), 400
+        
+        # Load the model
+        start_time = torch.cuda.Event(enable_timing=True) if torch.cuda.is_available() else None
+        end_time = torch.cuda.Event(enable_timing=True) if torch.cuda.is_available() else None
+        
+        if start_time:
+            start_time.record()
+        
+        loader = model_manager.get_model_loader(model_name, model_type, filename, force_reload)
+        
+        if end_time:
+            end_time.record()
+            torch.cuda.synchronize()
+            load_time = start_time.elapsed_time(end_time) / 1000.0  # Convert to seconds
+        else:
+            load_time = None
+        
+        # Get model information
+        model_info = loader.get_model_info()
+        model_info["load_time_seconds"] = load_time
+        
+        return jsonify({
+            "success": True,
+            "message": f"Model {model_name} ({model_type}) loaded successfully",
+            "model_info": model_info,
+            "validation": validation
+        }), 200
+        
+    except Exception as e:
+        logger.error(f"Failed to load model: {str(e)}", exc_info=True)
+        return jsonify({
+            "success": False,
+            "error": f"Model loading failed: {str(e)}"
+        }), 500
+
+@model_management_bp.route('/generate', methods=['POST'])
+def generate_text():
+    """
+    Generate text using a specific model
+    
+    Request body:
+    {
+        "model_name": "microsoft/Phi-3-mini-4k-instruct-gguf",
+        "model_type": "gguf",
+        "filename": "Phi-3-mini-4k-instruct-q4.gguf",  # Optional for GGUF
+        "prompt": "Generate a medical summary for...",
+        "max_tokens": 512,
+        "temperature": 0.7,
+        "top_p": 0.95
+    }
+    """
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+        
+        model_name = data.get("model_name")
+        model_type = data.get("model_type")
+        filename = data.get("filename")
+        prompt = data.get("prompt")
+        
+        if not all([model_name, prompt]):
+            return jsonify({"error": "model_name and prompt are required"}), 400
+        
+        # Auto-detect model type if not provided
+        if not model_type:
+            model_type = detect_model_type(model_name)
+        
+        # Generate text
+        start_time = torch.cuda.Event(enable_timing=True) if torch.cuda.is_available() else None
+        end_time = torch.cuda.Event(enable_timing=True) if torch.cuda.is_available() else None
+        
+        if start_time:
+            start_time.record()
+        
+        generated_text = model_manager.generate_text(
+            model_name, 
+            model_type, 
+            prompt, 
+            filename,
+            **{k: v for k, v in data.items() if k not in ["model_name", "model_type", "filename", "prompt"]}
+        )
+        
+        if end_time:
+            end_time.record()
+            torch.cuda.synchronize()
+            generation_time = start_time.elapsed_time(end_time) / 1000.0
+        else:
+            generation_time = None
+        
+        return jsonify({
+            "success": True,
+            "generated_text": generated_text,
+            "model_name": model_name,
+            "model_type": model_type,
+            "generation_time_seconds": generation_time,
+            "text_length": len(generated_text)
+        }), 200
+        
+    except Exception as e:
+        logger.error(f"Text generation failed: {str(e)}", exc_info=True)
+        return jsonify({
+            "success": False,
+            "error": f"Text generation failed: {str(e)}"
+        }), 500
+
+@model_management_bp.route('/info', methods=['GET'])
+def get_model_information():
+    """
+    Get information about a specific model or all loaded models
+    
+    Query parameters:
+    - model_name: Optional, specific model to get info for
+    - model_type: Optional, filter by model type
+    """
+    try:
+        model_name = request.args.get("model_name")
+        model_type = request.args.get("model_type")
+        
+        if model_name:
+            # Get info for specific model
+            if not model_type:
+                model_type = detect_model_type(model_name)
+            
+            validation = validate_model_config(model_name, model_type)
+            model_info = get_model_info(model_name, model_type)
+            
+            return jsonify({
+                "success": True,
+                "model_info": model_info,
+                "validation": validation
+            }), 200
+        else:
+            # Get info for all loaded models
+            loaded_models = model_manager.list_loaded_models()
+            
+            # Filter by type if specified
+            if model_type:
+                loaded_models = {
+                    k: v for k, v in loaded_models.items() 
+                    if v.get("model_type") == model_type
+                }
+            
+            return jsonify({
+                "success": True,
+                "loaded_models": loaded_models,
+                "total_models": len(loaded_models)
+            }), 200
+            
+    except Exception as e:
+        logger.error(f"Failed to get model information: {str(e)}", exc_info=True)
+        return jsonify({
+            "success": False,
+            "error": f"Failed to get model information: {str(e)}"
+        }), 500
+
+@model_management_bp.route('/defaults', methods=['GET'])
+def get_default_models():
+    """
+    Get default models for different model types
+    """
+    try:
+        from ..utils.model_config import DEFAULT_MODELS, SPACES_OPTIMIZED_MODELS
+        
+        return jsonify({
+            "success": True,
+            "default_models": DEFAULT_MODELS,
+            "spaces_optimized_models": SPACES_OPTIMIZED_MODELS
+        }), 200
+        
+    except Exception as e:
+        logger.error(f"Failed to get default models: {str(e)}", exc_info=True)
+        return jsonify({
+            "success": False,
+            "error": f"Failed to get default models: {str(e)}"
+        }), 500
+
+@model_management_bp.route('/clear_cache', methods=['POST'])
+def clear_model_cache():
+    """
+    Clear the model cache and free memory
+    """
+    try:
+        # Get cache info before clearing
+        loaded_models = model_manager.list_loaded_models()
+        cache_size = len(loaded_models)
+        
+        # Clear cache
+        model_manager.clear_cache()
+        
+        return jsonify({
+            "success": True,
+            "message": f"Model cache cleared successfully",
+            "cleared_models": cache_size,
+            "memory_freed": "GPU and CPU memory cleared"
+        }), 200
+        
+    except Exception as e:
+        logger.error(f"Failed to clear cache: {str(e)}", exc_info=True)
+        return jsonify({
+            "success": False,
+            "error": f"Failed to clear cache: {str(e)}"
+        }), 500
+
+@model_management_bp.route('/switch', methods=['POST'])
+def switch_model():
+    """
+    Switch the model used by a specific agent
+    
+    Request body:
+    {
+        "agent_name": "patient_summarizer",
+        "model_name": "microsoft/Phi-3-mini-4k-instruct-gguf",
+        "model_type": "gguf",
+        "filename": "Phi-3-mini-4k-instruct-q4.gguf"  # Optional for GGUF
+    }
+    """
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+        
+        agent_name = data.get("agent_name")
+        model_name = data.get("model_name")
+        model_type = data.get("model_type")
+        filename = data.get("filename")
+        
+        if not all([agent_name, model_name]):
+            return jsonify({"error": "agent_name and model_name are required"}), 400
+        
+        # Auto-detect model type if not provided
+        if not model_type:
+            model_type = detect_model_type(model_name)
+        
+        # Validate model configuration
+        validation = validate_model_config(model_name, model_type)
+        if not validation["valid"]:
+            return jsonify({
+                "error": "Invalid model configuration",
+                "validation": validation
+            }), 400
+        
+        # Get the agent from the current app context
+        from flask import current_app
+        agents = getattr(current_app, 'agents', {})
+        
+        if agent_name not in agents:
+            return jsonify({
+                "error": f"Agent '{agent_name}' not found",
+                "available_agents": list(agents.keys())
+            }), 404
+        
+        agent = agents[agent_name]
+        
+        # Update the agent's model if it supports it
+        if hasattr(agent, 'update_model'):
+            agent.update_model(model_name, model_type)
+            message = f"Agent '{agent_name}' model updated to {model_name} ({model_type})"
+        elif hasattr(agent, 'model_loader'):
+            # Try to update the model loader
+            try:
+                from ..utils.model_manager import model_manager
+                agent.model_loader = model_manager.get_model_loader(model_name, model_type, filename)
+                message = f"Agent '{agent_name}' model loader updated to {model_name} ({model_type})"
+            except Exception as e:
+                return jsonify({
+                    "error": f"Failed to update agent model loader: {str(e)}"
+                }), 500
+        else:
+            return jsonify({
+                "error": f"Agent '{agent_name}' does not support model switching"
+            }), 400
+        
+        return jsonify({
+            "success": True,
+            "message": message,
+            "agent_name": agent_name,
+            "model_name": model_name,
+            "model_type": model_type,
+            "validation": validation
+        }), 200
+        
+    except Exception as e:
+        logger.error(f"Failed to switch model: {str(e)}", exc_info=True)
+        return jsonify({
+            "success": False,
+            "error": f"Failed to switch model: {str(e)}"
+        }), 500
+
+@model_management_bp.route('/health', methods=['GET'])
+def model_health_check():
+    """
+    Health check for the model management system
+    """
+    try:
+        # Check if model manager is accessible
+        loaded_models = model_manager.list_loaded_models()
+        
+        # Check GPU memory if available
+        gpu_info = {}
+        if torch.cuda.is_available():
+            gpu_info = {
+                "available": True,
+                "device_count": torch.cuda.device_count(),
+                "current_device": torch.cuda.current_device(),
+                "memory_allocated": f"{torch.cuda.memory_allocated() / 1024**3:.2f} GB",
+                "memory_reserved": f"{torch.cuda.memory_reserved() / 1024**3:.2f} GB"
+            }
+        else:
+            gpu_info = {"available": False}
+        
+        return jsonify({
+            "success": True,
+            "status": "healthy",
+            "model_manager": "operational",
+            "loaded_models_count": len(loaded_models),
+            "gpu_info": gpu_info,
+            "timestamp": torch.cuda.Event(enable_timing=True).elapsed_time(torch.cuda.Event(enable_timing=True)) if torch.cuda.is_available() else None
+        }), 200
+        
+    except Exception as e:
+        logger.error(f"Health check failed: {str(e)}", exc_info=True)
+        return jsonify({
+            "success": False,
+            "status": "unhealthy",
+            "error": f"Health check failed: {str(e)}"
+        }), 500
+
+# Register the blueprint
+def register_model_management_routes(app):
+    """Register model management routes with the Flask app"""
+    app.register_blueprint(model_management_bp)
+    logger.info("Model management routes registered successfully")

ai_med_extract/app.py

@@ -0,0 +1,175 @@
+import os
+import logging
+from flask import Flask, jsonify
+from flask_cors import CORS
+import whisper
+from dotenv import load_dotenv
+from .agents.text_extractor import TextExtractorAgent
+from .agents.phi_scrubber import PHIScrubberAgent
+from .agents.phi_scrubber import MedicalTextUtils
+from .agents.summarizer import SummarizerAgent
+from .agents.medical_data_extractor import MedicalDataExtractorAgent
+from .agents.medical_data_extractor import MedicalDocDataExtractorAgent
+from .agents.patient_summary_agent import PatientSummarizerAgent
+from .utils.model_manager import model_manager
+import torch
+torch.set_num_threads(1)  # CPU efficiency for HF Spaces
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('/tmp/app.log')
+    ]
+)
+
+app = Flask(__name__)
+CORS(app)
+
+# Configure upload directory with safe fallbacks (avoid creating /data at import time)
+def _resolve_upload_dir() -> str:
+    try:
+        # Prefer /data/uploads if it already exists and is writable
+        data_dir = '/data/uploads'
+        if os.path.isdir('/data') and (os.path.isdir(data_dir) or os.access('/data', os.W_OK)):
+            os.makedirs(data_dir, exist_ok=True)
+            return data_dir
+    except Exception:
+        pass
+    # Fallback to /tmp/uploads which is always writable on Spaces
+    tmp_dir = '/tmp/uploads'
+    os.makedirs(tmp_dir, exist_ok=True)
+    return tmp_dir
+
+app.config['UPLOAD_FOLDER'] = _resolve_upload_dir()
+app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # 100 MB max file size
+
+# Set cache directories
+CACHE_DIRS = {
+    'HF_HOME': '/tmp/huggingface',
+    'XDG_CACHE_HOME': '/tmp',
+    'TORCH_HOME': '/tmp/torch',
+    'WHISPER_CACHE': '/tmp/whisper'
+}
+
+for env_var, path in CACHE_DIRS.items():
+    os.environ[env_var] = path
+    os.makedirs(path, exist_ok=True)
+
+# WhisperModelLoader for audio transcription (CPU-only)
+class WhisperModelLoader:
+    _instance = None
+    
+    def __init__(self):
+        self._model = None
+        
+    @staticmethod
+    def get_instance():
+        if WhisperModelLoader._instance is None:
+            WhisperModelLoader._instance = WhisperModelLoader()
+        return WhisperModelLoader._instance
+    
+    def load(self):
+        if self._model is None:
+            try:
+                logging.info("Loading Whisper tiny model (CPU)...")
+                self._model = whisper.load_model(
+                    "tiny",
+                    device="cpu",  # Explicit CPU for Spaces
+                    download_root=os.environ.get('WHISPER_CACHE', '/tmp/whisper')
+                )
+                logging.info("Whisper model loaded successfully")
+            except Exception as e:
+                logging.error(f"Failed to load Whisper model: {str(e)}", exc_info=True)
+                raise
+        return self._model
+        
+    def transcribe(self, audio_path):
+        model = self.load()
+        return model.transcribe(audio_path, fp16=False)  # CPU, no FP16
+
+# Initialize agents with unified model manager (CPU-friendly small models for HF Spaces)
+try:
+    from .utils.model_manager import model_manager
+    
+    # Initialize basic agents that don't require specific models
+    text_extractor_agent = TextExtractorAgent()
+    phi_scrubber_agent = PHIScrubberAgent()
+    
+    # Initialize model-dependent agents with small CPU models
+    try:
+        # Small summarization model (~400MB)
+        summ_loader = model_manager.get_model_loader("facebook/bart-base", "summarization")
+        summarizer_agent = SummarizerAgent(summ_loader)
+        logging.info("SummarizerAgent initialized with bart-base")
+    except Exception as e:
+        logging.warning(f"Summarizer fallback: {e}")
+        from .utils.model_loader_gguf import create_fallback_pipeline
+        class FallbackSummarizer:
+            def generate(self, text, **kwargs):
+                return create_fallback_pipeline().generate_full_summary(text)
+        summarizer_agent = SummarizerAgent(FallbackSummarizer())
+    
+    try:
+        # Small text-generation model (~350MB)
+        med_loader = model_manager.get_model_loader("distilgpt2", "text-generation")
+        med_generator = med_loader.load()
+        medical_data_extractor_agent = MedicalDataExtractorAgent(med_generator)
+        logging.info("MedicalDataExtractorAgent initialized with distilgpt2")
+    except Exception as e:
+        logging.warning(f"Medical extractor fallback: {e}")
+        from .utils.model_loader_gguf import create_fallback_pipeline
+        class FallbackExtractor:
+            def generate(self, prompt, **kwargs):
+                return create_fallback_pipeline().generate(prompt)
+        medical_data_extractor_agent = MedicalDataExtractorAgent(FallbackExtractor())
+    
+    # Initialize patient summarizer with small model
+    try:
+        patient_summarizer_agent = PatientSummarizerAgent(
+            model_name="sshleifer/distilbart-cnn-6-6",  # Smaller medical-like summarizer (~1GB)
+            model_type="summarization"
+        )
+        logging.info("PatientSummarizerAgent initialized with distilbart")
+    except Exception as e:
+        logging.warning(f"Patient summarizer fallback: {e}")
+        patient_summarizer_agent = PatientSummarizerAgent(
+            model_name="facebook/bart-base",
+            model_type="summarization"
+        )
+    
+    # Pass all agents and models to routes
+    agents = {
+        "text_extractor": text_extractor_agent,
+        "phi_scrubber": phi_scrubber_agent,
+        "summarizer": summarizer_agent,
+        "medical_data_extractor": medical_data_extractor_agent,
+        "whisper_model": WhisperModelLoader.get_instance(),
+        "patient_summarizer": patient_summarizer_agent,
+        "model_manager": model_manager,  # Add unified model manager
+    }
+    
+    from .api.routes import register_routes
+    register_routes(app, agents)
+    
+    logging.info("Application initialized successfully with CPU-friendly models")
+    
+except Exception as e:
+    logging.error(f"Failed to initialize application: {str(e)}", exc_info=True)
+    raise
+
+@app.errorhandler(Exception)
+def handle_error(error):
+    logging.error(f"Unhandled error: {str(error)}", exc_info=True)
+    return jsonify({
+        "error": str(error),
+        "status": "error"
+    }), 500
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, debug=False)

ai_med_extract/gradio_app.py

@@ -0,0 +1,70 @@
+import gradio as gr
+import os
+from .app import agents
+import tempfile
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+def process_document(file, process_type):
+    try:
+        # Create a temporary file to store the upload
+        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.name)[1]) as temp_file:
+            temp_file.write(file.read())
+            temp_path = temp_file.name
+
+        results = {}
+        
+        if process_type == "text_extraction":
+            results["extracted_text"] = agents["text_extractor"].extract_text(temp_path)
+            results["phi_scrubbed"] = agents["phi_scrubber"].scrub_phi(results["extracted_text"])
+            
+        elif process_type == "medical_data":
+            text = agents["text_extractor"].extract_text(temp_path)
+            results["medical_data"] = agents["medical_data_extractor"].extract_medical_data(text)
+            
+        elif process_type == "summarization":
+            text = agents["text_extractor"].extract_text(temp_path)
+            results["summary"] = agents["summarizer"].summarize(text)
+            
+        elif process_type == "audio_transcription":
+            results["transcription"] = agents["whisper_model"].transcribe(temp_path)
+            
+        # Clean up temporary file
+        os.unlink(temp_path)
+        
+        return results
+        
+    except Exception as e:
+        logging.error(f"Error processing document: {str(e)}", exc_info=True)
+        return {"error": str(e)}
+
+# Create the Gradio interface
+def create_interface():
+    with gr.Blocks(title="Medical Document Processor") as interface:
+        gr.Markdown("# Medical Document Processor")
+        gr.Markdown("Upload your medical document and select the processing type.")
+        
+        with gr.Row():
+            with gr.Column():
+                file_input = gr.File(label="Upload Document")
+                process_type = gr.Radio(
+                    choices=["text_extraction", "medical_data", "summarization", "audio_transcription"],
+                    label="Processing Type"
+                )
+                process_btn = gr.Button("Process Document")
+            
+            with gr.Column():
+                output = gr.JSON(label="Results")
+        
+        process_btn.click(
+            fn=process_document,
+            inputs=[file_input, process_type],
+            outputs=output
+        )
+    
+    return interface
+
+# Create and launch the interface
+interface = create_interface()
+interface.launch(server_name="0.0.0.0", server_port=7860) 

ai_med_extract/utils/__init__.py

@@ -0,0 +1 @@
+# ai_med_extract/utils/__init__.py