Update src/ai_processor.py

src/ai_processor.py

@@ -1,12 +1,12 @@
 import os
+import io
+import base64
 import logging
 import cv2
 import numpy as np
 from PIL import Image
 import torch
-import json
 from datetime import datetime
-import tensorflow as tf
 from transformers import pipeline
 from ultralytics import YOLO
 from tensorflow.keras.models import load_model
@@ -16,9 +16,21 @@ from langchain_community.embeddings import HuggingFaceEmbeddings
 from langchain_community.vectorstores import FAISS
 from huggingface_hub import HfApi, HfFolder
 import spaces
-
 from .config import Config
 
+# Inline system prompt for MedGemma GPU pipeline
+default_system_prompt = (
+    "You are a world-class medical AI assistant specializing in wound care "
+    "with expertise in wound assessment and treatment. Provide concise, "
+    "evidence-based medical assessments focusing on: (1) Precise wound "
+    "classification based on tissue type and appearance, (2) Specific "
+    "treatment recommendations with exact product names or interventions when "
+    "appropriate, (3) Objective evaluation of healing progression or deterioration "
+    "indicators, and (4) Clear follow-up timelines. Avoid general statements and "
+    "prioritize actionable insights based on the visual analysis measurements and "
+    "patient context."
+)
+
 class AIProcessor:
     def __init__(self):
         self.models_cache = {}
@@ -28,458 +40,207 @@ class AIProcessor:
         self._initialize_models()
 
     def _initialize_models(self):
-        """Initialize all AI models including real-time models"""
-        try:
-            # Set HuggingFace token
-            if self.config.HF_TOKEN:
-                HfFolder.save_token(self.config.HF_TOKEN)
-                logging.info("HuggingFace token set successfully")
+        """Initialize AI models; only MedGemma uses GPU."""
+        # Set HuggingFace token
+        if self.config.HF_TOKEN:
+            HfFolder.save_token(self.config.HF_TOKEN)
+            logging.info("HuggingFace token set successfully")
 
-            # Initialize MedGemma pipeline for medical text generation
-            try:
-                self.models_cache["medgemma_pipe"] = pipeline(
-                    "image-text-to-text",
-                    model="google/medgemma-4b-it",
-                    torch_dtype=torch.bfloat16,
-                    offload_folder="offload",
-                    device_map="cuda",
-                    token=self.config.HF_TOKEN
-                )
-                logging.info("✅ MedGemma pipeline loaded successfully")
-            except Exception as e:
-                logging.warning(f"MedGemma pipeline not available: {e}")
-
-            # Initialize YOLO model for wound detection
-            try:
-                self.models_cache["det"] = YOLO(self.config.YOLO_MODEL_PATH)
-                logging.info("✅ YOLO detection model loaded successfully")
-            except Exception as e:
-                logging.warning(f"YOLO model not available: {e}")
-
-            # Initialize segmentation model
-            try:
-                self.models_cache["seg"] = load_model(self.config.SEG_MODEL_PATH, compile=False)
-                logging.info("✅ Segmentation model loaded successfully")
-            except Exception as e:
-                logging.warning(f"Segmentation model not available: {e}")
-
-            # Initialize wound classification model
-            try:
-                self.models_cache["cls"] = pipeline(
-                    "image-classification", 
-                    model="Hemg/Wound-classification", 
-                    token=self.config.HF_TOKEN, 
-                    device="cpu"
-                )
-                logging.info("✅ Wound classification model loaded successfully")
-            except Exception as e:
-                logging.warning(f"Wound classification model not available: {e}")
+        # MedGemma pipeline on GPU
+        try:
+            self.models_cache['medgemma_pipe'] = pipeline(
+                'image-text-to-text',
+                model='google/medgemma-4b-it',
+                device='cuda',
+                torch_dtype=torch.bfloat16,
+                offload_folder='offload',
+                token=self.config.HF_TOKEN
+            )
+            logging.info("✅ MedGemma pipeline loaded on GPU")
+        except Exception as e:
+            logging.warning(f"MedGemma pipeline not available: {e}")
 
-            # Initialize embedding model for knowledge base
-            try:
-                self.models_cache["embedding_model"] = HuggingFaceEmbeddings(
-                    model_name="sentence-transformers/all-MiniLM-L6-v2", 
-                    model_kwargs={'device': 'cpu'}
-                )
-                logging.info("✅ Embedding model loaded successfully")
-            except Exception as e:
-                logging.warning(f"Embedding model not available: {e}")
+        # YOLO detection on CPU
+        try:
+            self.models_cache['det'] = YOLO(self.config.YOLO_MODEL_PATH)
+            logging.info("✅ YOLO detection model loaded on CPU")
+        except Exception as e:
+            logging.warning(f"YOLO model not available: {e}")
 
-            logging.info("✅ All models loaded.")
-            self._load_knowledge_base()
+        # Segmentation model on CPU
+        try:
+            self.models_cache['seg'] = load_model(self.config.SEG_MODEL_PATH, compile=False)
+            logging.info("✅ Segmentation model loaded on CPU")
+        except Exception as e:
+            logging.warning(f"Segmentation model not available: {e}")
 
+        # Classification on CPU
+        try:
+            self.models_cache['cls'] = pipeline(
+                'image-classification',
+                model='Hemg/Wound-classification',
+                token=self.config.HF_TOKEN,
+                device='cpu'
+            )
+            logging.info("✅ Wound classification model loaded on CPU")
         except Exception as e:
-            logging.error(f"Error initializing AI models: {e}")
+            logging.warning(f"Wound classification model not available: {e}")
 
-    def _load_knowledge_base(self):
-        """Load knowledge base from PDF guidelines"""
+        # Embedding for knowledge base
         try:
-            documents = []
-            for pdf_path in self.config.GUIDELINE_PDFS:
-                if os.path.exists(pdf_path):
-                    loader = PyPDFLoader(pdf_path)
-                    docs = loader.load()
-                    documents.extend(docs)
-                    logging.info(f"Loaded PDF: {pdf_path}")
+            self.models_cache['embedding_model'] = HuggingFaceEmbeddings(
+                model_name='sentence-transformers/all-MiniLM-L6-v2',
+                model_kwargs={'device': 'cpu'}
+            )
+            logging.info("✅ Embedding model loaded on CPU")
+        except Exception as e:
+            logging.warning(f"Embedding model not available: {e}")
 
-            if documents and 'embedding_model' in self.models_cache:
-                # Split documents into chunks
-                text_splitter = RecursiveCharacterTextSplitter(
-                    chunk_size=1000,
-                    chunk_overlap=100
-                )
-                chunks = text_splitter.split_documents(documents)
-                
-                # Create vector store
-                vectorstore = FAISS.from_documents(chunks, self.models_cache['embedding_model'])
-                self.knowledge_base_cache['vectorstore'] = vectorstore
-                logging.info(f"✅ Knowledge base loaded with {len(chunks)} chunks")
-            else:
-                self.knowledge_base_cache['vectorstore'] = None
-                logging.warning("Knowledge base not available - no PDFs found or embedding model unavailable")
+        # Load knowledge base
+        self._load_knowledge_base()
 
-        except Exception as e:
-            logging.warning(f"Knowledge base loading error: {e}")
+    def _load_knowledge_base(self):
+        """Load PDF guidelines into a FAISS vector store."""
+        docs = []
+        for pdf in self.config.GUIDELINE_PDFS:
+            if os.path.exists(pdf):
+                loader = PyPDFLoader(pdf)
+                docs.extend(loader.load())
+                logging.info(f"Loaded PDF: {pdf}")
+
+        if docs and 'embedding_model' in self.models_cache:
+            splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+            chunks = splitter.split_documents(docs)
+            vs = FAISS.from_documents(chunks, self.models_cache['embedding_model'])
+            self.knowledge_base_cache['vectorstore'] = vs
+            logging.info(f"✅ Knowledge base loaded ({len(chunks)} chunks)")
+        else:
             self.knowledge_base_cache['vectorstore'] = None
+            logging.warning("Knowledge base unavailable")
 
-    @spaces.GPU(enable_queue=True, duration=120) 
     def perform_visual_analysis(self, image_pil):
-        """Perform comprehensive visual analysis of wound image."""
+        """Detect & segment on CPU; return only paths + metrics."""
         try:
-            # Convert PIL to OpenCV format
-            image_cv = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
-    
-            # YOLO detection
-            if 'det' not in self.models_cache:
-                raise ValueError("YOLO detection model not available.")
-    
-            results = self.models_cache['det'].predict(image_cv, verbose=False, device="cpu")
-    
-            if not results or not results[0].boxes:
-                raise ValueError("No wound detected in the image.")
-    
-            # Extract bounding box
-            box = results[0].boxes[0].xyxy[0].cpu().numpy().astype(int)
-            x1, y1, x2, y2 = box
-            region_cv = image_cv[y1:y2, x1:x2]
-    
-            # Save detection image
-            detection_image_cv = image_cv.copy()
-            cv2.rectangle(detection_image_cv, (x1, y1), (x2, y2), (0, 255, 0), 2)
-            os.makedirs(os.path.join(self.config.UPLOADS_DIR, "analysis"), exist_ok=True)
-            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-            detection_image_path = os.path.join(self.config.UPLOADS_DIR, "analysis", f"detection_{timestamp}.png")
-            cv2.imwrite(detection_image_path, detection_image_cv)
-            detection_image_pil = Image.fromarray(cv2.cvtColor(detection_image_cv, cv2.COLOR_BGR2RGB))
-    
-            # Initialize outputs
+            img_cv = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
+            # YOLO detect
+            res = self.models_cache['det'].predict(img_cv, verbose=False)[0]
+            if not res.boxes:
+                raise ValueError("No wound detected")
+            # Bounding box
+            x1, y1, x2, y2 = res.boxes.xyxy[0].cpu().numpy().astype(int)
+            region = img_cv[y1:y2, x1:x2]
+            # Save detection overlay
+            det_vis = img_cv.copy()
+            cv2.rectangle(det_vis, (x1, y1), (x2, y2), (0,255,0), 2)
+            os.makedirs(f"{self.config.UPLOADS_DIR}/analysis", exist_ok=True)
+            ts = datetime.now().strftime('%Y%m%d_%H%M%S')
+            det_path = f"{self.config.UPLOADS_DIR}/analysis/detection_{ts}.png"
+            cv2.imwrite(det_path, det_vis)
+            # Initialize metrics & seg
             length = breadth = area = 0
-            segmentation_image_pil = None
-            segmentation_image_path = None
-    
-            # Segmentation (optional)
+            seg_path = None
+            # Segmentation
             if 'seg' in self.models_cache:
-                input_size = self.models_cache['seg'].input_shape[1:3]  # (height, width)
-                resized_region = cv2.resize(region_cv, (input_size[1], input_size[0]))
-    
-                seg_input = np.expand_dims(resized_region / 255.0, 0)
-                mask_pred = self.models_cache['seg'].predict(seg_input, verbose=0)[0]
-                mask_np = (mask_pred[:, :, 0] > 0.5).astype(np.uint8)
-    
-                # Resize mask back to original region size
-                mask_resized = cv2.resize(mask_np, (region_cv.shape[1], region_cv.shape[0]), interpolation=cv2.INTER_NEAREST)
-    
-                # Overlay mask on region for visualization
-                overlay = region_cv.copy()
-                overlay[mask_resized == 1] = [0, 0, 255]  # Red overlay
-    
-                # Blend overlay for final output
-                segmented_visual = cv2.addWeighted(region_cv, 0.7, overlay, 0.3, 0)
-    
-                # Save segmentation image
-                segmentation_image_path = os.path.join(self.config.UPLOADS_DIR, "analysis", f"segmentation_{timestamp}.png")
-                cv2.imwrite(segmentation_image_path, segmented_visual)
-                segmentation_image_pil = Image.fromarray(cv2.cvtColor(segmented_visual, cv2.COLOR_BGR2RGB))
-    
-                # Wound measurements from resized mask
-                contours, _ = cv2.findContours(mask_resized, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-                if contours:
-                    cnt = max(contours, key=cv2.contourArea)
-                    x, y, w, h = cv2.boundingRect(cnt)
-                    length = round(h / self.px_per_cm, 2)
-                    breadth = round(w / self.px_per_cm, 2)
-                    area = round(cv2.contourArea(cnt) / (self.px_per_cm ** 2), 2)
-    
-            # Classification (optional)
-            wound_type = "Unknown"
+                h, w = self.models_cache['seg'].input_shape[1:3]
+                inp = cv2.resize(region, (w,h)) / 255.0
+                mask = (self.models_cache['seg'].predict(np.expand_dims(inp,0))[0,:,:,0] > 0.5).astype(np.uint8)
+                mask_rs = cv2.resize(mask, (region.shape[1], region.shape[0]), interpolation=cv2.INTER_NEAREST)
+                ov = region.copy()
+                ov[mask_rs==1] = [0,0,255]
+                seg_vis = cv2.addWeighted(region,0.7,ov,0.3,0)
+                seg_path = f"{self.config.UPLOADS_DIR}/analysis/segmentation_{ts}.png"
+                cv2.imwrite(seg_path, seg_vis)
+                # measure
+                cnts, _ = cv2.findContours(mask_rs, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+                if cnts:
+                    cnt = max(cnts, key=cv2.contourArea)
+                    _,_,w0,h0 = cv2.boundingRect(cnt)
+                    length = round(h0/self.px_per_cm,2)
+                    breadth= round(w0/self.px_per_cm,2)
+                    area   = round(cv2.contourArea(cnt)/(self.px_per_cm**2),2)
+            # Classification
+            wound_type = 'Unknown'
             if 'cls' in self.models_cache:
                 try:
-                    region_pil = Image.fromarray(cv2.cvtColor(region_cv, cv2.COLOR_BGR2RGB))
-                    cls_result = self.models_cache['cls'](region_pil)
-                    wound_type = max(cls_result, key=lambda x: x['score'])['label']
-                except Exception as e:
-                    logging.warning(f"Wound classification error: {e}")
-    
+                    label = self.models_cache['cls'](Image.fromarray(cv2.cvtColor(region, cv2.COLOR_BGR2RGB)))
+                    wound_type = max(label, key=lambda x: x['score'])['label']
+                except Exception:
+                    pass
             return {
                 'wound_type': wound_type,
                 'length_cm': length,
                 'breadth_cm': breadth,
                 'surface_area_cm2': area,
-                'detection_confidence': float(results[0].boxes[0].conf.cpu().item()),
-                'bounding_box': box.tolist(),
-                'detection_image_path': detection_image_path,
-                'detection_image_pil': detection_image_pil,
-                'segmentation_image_path': segmentation_image_path,
-                'segmentation_image_pil': segmentation_image_pil
+                'detection_confidence': float(res.boxes.conf[0].cpu().item()),
+                'detection_image_path': det_path,
+                'segmentation_image_path': seg_path
             }
-    
         except Exception as e:
             logging.error(f"Visual analysis error: {e}")
-            raise ValueError(f"Visual analysis failed: {str(e)}")
-
+            raise
 
     def query_guidelines(self, query: str):
-        """Query the knowledge base for relevant guidelines"""
-        try:
-            vector_store = self.knowledge_base_cache.get("vectorstore")
-            if not vector_store:
-                return "Knowledge base unavailable - clinical guidelines not loaded"
-
-            # Retrieve relevant documents
-            retriever = vector_store.as_retriever(search_kwargs={"k": 10})
-            docs = retriever.invoke(query)
-            
-            if not docs:
-                return "No relevant guidelines found for the query"
-
-            # Format the results
-            formatted_results = []
-            for doc in docs:
-                source = doc.metadata.get('source', 'Unknown')
-                page = doc.metadata.get('page', 'N/A')
-                content = doc.page_content.strip()
-                formatted_results.append(f"Source: {source}, Page: {page}\nContent: {content}")
-
-            return "\n\n".join(formatted_results)
-
-        except Exception as e:
-            logging.error(f"Guidelines query error: {e}")
-            return f"Error querying guidelines: {str(e)}"
-
-    @spaces.GPU(enable_queue=True, duration=120) 
+        """Retrieve clinical guidelines from vectorstore."""
+        vs = self.knowledge_base_cache.get('vectorstore')
+        if not vs:
+            return "Clinical guidelines unavailable"
+        docs = vs.as_retriever(search_kwargs={'k':10}).invoke(query)
+        return '\n\n'.join(f"Source: {d.metadata.get('source','?')}, Page: {d.metadata.get('page','?')}\n{d.page_content}" for d in docs)
+
+    @spaces.GPU(enable_queue=True, duration=120)
     def generate_final_report(self, patient_info, visual_results, guideline_context, image_pil, max_new_tokens=None):
-        """Generate comprehensive medical report using MedGemma"""
-        try:
-            if 'medgemma_pipe' not in self.models_cache:
-                return self._generate_fallback_report(patient_info, visual_results, guideline_context)
-
-            max_tokens = max_new_tokens or self.config.MAX_NEW_TOKENS
-            
-            # Get detection and segmentation images if available
-            detection_image = visual_results.get('detection_image_pil', None)
-            segmentation_image = visual_results.get('segmentation_image_pil', None)
-            
-            # Create image paths for report
-            detection_path = visual_results.get('detection_image_path', '')
-            segmentation_path = visual_results.get('segmentation_image_path', '')
-            
-            # Create detailed prompt for medical analysis with image paths
-            prompt = f"""
-# Wound Care Report
-
-## Patient Information
-{patient_info}
-
-## Visual Analysis Summary
-- Wound Type: {visual_results.get('wound_type', 'Unknown')}
-- Length: {visual_results.get('length_cm', 0)} cm
-- Breadth: {visual_results.get('breadth_cm', 0)} cm
-- Surface Area: {visual_results.get('surface_area_cm2', 0)} cm²
-- Detection Confidence: {visual_results.get('detection_confidence', 0):.2f}
-
-## Clinical Reference
-{guideline_context}
-
-You are SmartHeal-AI Agent, a world-class wound care AI specialist trained in clinical wound assessment and guideline-based treatment planning.
-Your task is to process the following structured inputs (patient data, wound measurements, clinical guidelines, and image) and perform **clinical reasoning and decision-making** to generate a complete wound care report.
----
-🔍 **YOUR PROCESS — FOLLOW STRICTLY:**
-### Step 1: Clinical Reasoning (Chain-of-Thought)
-Use the provided information to think step-by-step about:
-- Patient’s risk factors (e.g. diabetes, age, healing limitations)
-- Wound characteristics (size, tissue appearance, moisture, infection signs)
-- Visual clues from the image (location, granulation, maceration, inflammation, surrounding skin)
-
----
--Step 2: Structured Clinical Report
-Generate the following report sections using markdown and medical terminology:
-**1. Clinical Summary**
-- Describe wound appearance and tissue types (e.g., slough, necrotic, granulating, epithelializing)
-- Include size, wound bed condition, peri-wound skin, and signs of infection or biofilm
-- Mention inferred location (e.g., heel, forefoot) if image allows
-- Summarize patient's systemic risk profile
-**2. Medicinal & Dressing Recommendations**
-Based on your analysis:
-- Recommend specific **wound care dressings** (e.g., hydrocolloid, alginate, foam, antimicrobial silver, etc.) suitable to wound moisture level and infection risk
-- Propose **topical or systemic agents** ONLY if relevant — include name classes (e.g., antiseptic: povidone iodine, antibiotic ointments, enzymatic debriders)
-- Mention **techniques** (e.g., sharp debridement, NPWT, moisture balance, pressure offloading, dressing frequency)
-- Avoid repeating guidelines — **apply them**
-**3. Key Risk Factors**
-Explain how the patient’s condition (e.g., diabetic, poor circulation, advanced age, poor hygiene) may affect wound healing
-**4. Prognosis & Monitoring Advice**
-- Mention how often wound should be reassessed
-- Indicate signs to monitor for deterioration or improvement
-- Include when escalation to specialist is necessary
-
-**Note:** Every dressing change is a chance for wound reassessment. Always perform a thorough wound evaluation at each dressing change.
-"""
-
-            # Prepare messages for MedGemma with all available images
-            content_list = [{"type": "text", "text": prompt}]
-            
-            # Add original image
-            if image_pil:
-                content_list.insert(0, {"type": "image", "image": image_pil})
-                
-            # Add detection image if available
-            if detection_image:
-                content_list.insert(1, {"type": "image", "image": detection_image})
-                
-            # Add segmentation image if available
-            if segmentation_image:
-                content_list.insert(2, {"type": "image", "image": segmentation_image})
-            
-            messages = [
-                {
-                    "role": "system",
-                    "content": [{"type": "text", "text": "You are a world-class medical AI assistant specializing in wound care with expertise in wound assessment and treatment. Provide concise, evidence-based medical assessments focusing on: (1) Precise wound classification based on tissue type and appearance, (2) Specific treatment recommendations with exact product names or interventions when appropriate, (3) Objective evaluation of healing progression or deterioration indicators, and (4) Clear follow-up timelines. Avoid general statements and prioritize actionable insights based on the visual analysis measurements and patient context."}],
-                },
-                {
-                    "role": "user",
-                    "content": content_list
-                }
-            ]
-
-            # Generate report using MedGemma
-            output = self.models_cache['medgemma_pipe'](
-                text=messages,
-                max_new_tokens=1024,
-                do_sample=False,
-            )
-            
-            generated_content = output[0]['generated_text'][-1].get('content', '').strip()
-            
-            # Include image paths in the final report for display in UI
-            if generated_content:
-                # Add image paths to the report for frontend display
-                image_paths_section = f"""
-## Analysis Images
-- Original Image: {image_pil}
-- Detection Image: {detection_path}
-- Segmentation Image: {segmentation_path}
-"""
-                generated_content = image_paths_section + generated_content
-                
-            return generated_content if generated_content else self._generate_fallback_report(patient_info, visual_results, guideline_context)
-
-        except Exception as e:
-            logging.error(f"MedGemma report generation error: {e}")
+        """Run MedGemma on GPU; return markdown report."""
+        if 'medgemma_pipe' not in self.models_cache:
             return self._generate_fallback_report(patient_info, visual_results, guideline_context)
+        # build messages
+        msgs = [{ 'role':'system', 'content':[{'type':'text','text': default_system_prompt}] },
+                { 'role':'user', 'content':[]}]
+        # images
+        if image_pil: msgs[1]['content'].append({'type':'image','image':image_pil})
+        for key in ('detection_image_path','segmentation_image_path'):
+            p = visual_results.get(key)
+            if p and os.path.exists(p):
+                msgs[1]['content'].append({'type':'image', 'image': Image.open(p)})
+        # text prompt stub (expand as needed)
+        prompt = f"## Patient\n{patient_info}\n## Visual Type: {visual_results['wound_type']}"
+        msgs[1]['content'].append({'type':'text','text':prompt})
+        out = self.models_cache['medgemma_pipe'](text=msgs, max_new_tokens=max_new_tokens or self.config.MAX_NEW_TOKENS)
+        report = out[0]['generated_text'][-1].get('content','')
+        return report or self._generate_fallback_report(patient_info, visual_results, guideline_context)
 
     def _generate_fallback_report(self, patient_info, visual_results, guideline_context):
-        """Generate a fallback report when MedGemma is not available"""
-        # Get image paths for report
-        detection_path = visual_results.get('detection_image_path', 'Not available')
-        segmentation_path = visual_results.get('segmentation_image_path', 'Not available')
-        
-        report = f"""
-# Wound Analysis Report
-## Patient Information
-{patient_info}
-
-## Visual Analysis Results
-- **Wound Type**: {visual_results.get('wound_type', 'Unknown')}
-- **Dimensions**: {visual_results.get('length_cm', 0)} cm × {visual_results.get('breadth_cm', 0)} cm
-- **Surface Area**: {visual_results.get('surface_area_cm2', 0)} cm²
-- **Detection Confidence**: {visual_results.get('detection_confidence', 0):.2f}
-
-## Analysis Images
-- **Detection Image**: {detection_path}
-- **Segmentation Image**: {segmentation_path}
-
-## Assessment
-Based on the visual analysis, this appears to be a {visual_results.get('wound_type', 'wound')} with measurable dimensions. 
-
-## Recommendations
-- Continue monitoring wound healing progress
-- Maintain proper wound hygiene
-- Follow appropriate dressing protocols
-- Seek medical attention if signs of infection develop
-
-## Clinical Guidelines
-{guideline_context[:500]}...
-
-*Note: This is an automated analysis. Please consult with a healthcare professional for definitive diagnosis and treatment.*
-"""
-        return report
+        """Produce text-only fallback."""
+        dp = visual_results.get('detection_image_path','N/A')
+        sp = visual_results.get('segmentation_image_path','N/A')
+        return f"# Report\n{patient_info}\nType: {visual_results['wound_type']}\nDetection Image: {dp}\nSegmentation Image: {sp}\nGuidelines: {guideline_context[:200]}..."
 
     def save_and_commit_image(self, image_pil):
-        """Save image locally and optionally upload to HuggingFace dataset"""
-        try:
-            # Ensure uploads directory exists
-            os.makedirs(self.config.UPLOADS_DIR, exist_ok=True)
-            
-            # Generate filename with timestamp
-            filename = f"{datetime.now().strftime('%Y-%m-%d_%H-%M-%S')}.png"
-            local_path = os.path.join(self.config.UPLOADS_DIR, filename)
-            
-            # Save image locally
-            image_pil.convert("RGB").save(local_path)
-            logging.info(f"Image saved locally: {local_path}")
-
-            # Upload to HuggingFace dataset if configured
-            if self.config.HF_TOKEN and self.config.DATASET_ID:
-                try:
-                    api = HfApi()
-                    api.upload_file(
-                        path_or_fileobj=local_path,
-                        path_in_repo=f"images/{filename}",
-                        repo_id=self.config.DATASET_ID,
-                        repo_type="dataset",
-                        commit_message=f"Upload wound image: {filename}"
-                    )
-                    logging.info("✅ Image uploaded to HuggingFace dataset")
-                except Exception as e:
-                    logging.warning(f"HuggingFace upload failed: {e}")
-
-            return local_path
-
-        except Exception as e:
-            logging.error(f"Image saving error: {e}")
-            return None
+        """Save locally and optionally to HuggingFace."""
+        os.makedirs(self.config.UPLOADS_DIR, exist_ok=True)
+        fn = f"{datetime.now():%Y%m%d_%H%M%S}.png"
+        path = os.path.join(self.config.UPLOADS_DIR, fn)
+        image_pil.convert('RGB').save(path)
+        if self.config.HF_TOKEN and self.config.DATASET_ID:
+            try:
+                api = HfApi()
+                api.upload_file(path_or_fileobj=path, path_in_repo=f"images/{fn}", repo_id=self.config.DATASET_ID, repo_type='dataset')
+            except Exception as e:
+                logging.warning(f"HF upload failed: {e}")
+        return path
 
-    
-    def full_analysis_pipeline(self, image, questionnaire_data):
-        """Complete analysis pipeline with real-time models"""
+    def full_analysis_pipeline(self, image_pil, questionnaire_data):
+        """Orchestrate CPU steps + GPU report."""
         try:
-            # Save the image
-            saved_path = self.save_and_commit_image(image)
-            
-            # Perform visual analysis
-            visual_results = self.perform_visual_analysis(image)
-            
-            # Format patient information
-            patient_info = ", ".join([f"{k}: {v}" for k, v in questionnaire_data.items() if v])
-            
-            # Create query for guidelines
-            wound_type = visual_results.get('wound_type', 'wound')
-            moisture = questionnaire_data.get('moisture', 'unknown')
-            infection = questionnaire_data.get('infection', 'unknown')
-            diabetic = questionnaire_data.get('diabetic', 'unknown')
-            
-            query = f"best practices for managing a {wound_type} with moisture level '{moisture}' and signs of infection '{infection}' in a patient who is diabetic '{diabetic}'"
-            
-            # Query guidelines
-            guideline_context = self.query_guidelines(query)
-            
-            # Generate final report
-            final_report = self.generate_final_report(patient_info, visual_results, guideline_context, image)
-            
-            return {
-                'success': True,
-                'visual_analysis': visual_results,
-                'report': final_report,
-                'saved_image_path': saved_path,
-                'timestamp': datetime.now().isoformat()
-            }
-
+            saved = self.save_and_commit_image(image_pil)
+            vis = self.perform_visual_analysis(image_pil)
+            info = ", ".join(f"{k}:{v}" for k,v in questionnaire_data.items() if v)
+            gc = self.query_guidelines(info)
+            report = self.generate_final_report(info, vis, gc, image_pil)
+            return {'success':True, 'visual_analysis':vis, 'report':report, 'saved_image_path':saved}
         except Exception as e:
-            logging.error(f"Full analysis pipeline error: {e}")
-            return {
-                'success': False,
-                'error': str(e),
-                'timestamp': datetime.now().isoformat()
-            }
+            logging.error(f"Pipeline error: {e}")
+            return {'success':False, 'error':str(e)}
+
 
     # Legacy methods for backward compatibility
     def analyze_wound(self, image, questionnaire_data):