Upload 7 files

.env.example

@@ -0,0 +1,9 @@
+# ClarirAI Environment Variables
+
+# OpenRouter API Configuration
+OPENAI_API_KEY=your_openrouter_api_key_here
+OPENROUTER_API_BASE=https://openrouter.ai/api/v1
+OPENROUTER_REFERER=https://clarirai.example.com
+OPENROUTER_MODEL=mistralai/mistral-7b-instruct
+
+# You can set these in the Hugging Face Spaces secrets section

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.12-slim
+
+# Set working directory
+WORKDIR /app
+
+# Copy all project files
+COPY requirements.txt .
+COPY model.onnx .
+COPY main.py .
+COPY prompts.py .
+COPY app.py .
+
+# Create directory for environment variables
+RUN mkdir -p /app/.env
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose port 7860 (required for Hugging Face Spaces)
+EXPOSE 7860
+
+# Run the FastAPI app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,8 @@
+# Hugging Face Spaces entry point
+# This file redirects to our main.py application
+
+from main import app
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=7860)

main.py

@@ -0,0 +1,546 @@
+import io
+import logging
+import time
+from datetime import datetime
+from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks, Query, Body
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, FileResponse
+import onnxruntime
+import numpy as np
+from PIL import Image
+import uvicorn
+import uuid
+import json
+import os
+import tempfile
+from typing import Optional, List, Dict
+
+# Import for .env file support
+try:
+    from dotenv import load_dotenv
+    load_dotenv()  # Load environment variables from .env file
+    ENV_LOADED = True
+except ImportError:
+    ENV_LOADED = False
+    logging.warning("python-dotenv package not installed. Using environment variables directly.")
+
+# Import for OpenRouter integration
+try:
+    import openai
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    logging.warning("OpenAI package not installed. AI consultation features will be disabled.")
+
+# Import for report generation
+try:
+    from docx import Document
+    DOCX_AVAILABLE = True
+except ImportError:
+    DOCX_AVAILABLE = False
+    logging.warning("python-docx package not installed. Report generation will be disabled.")
+
+# Import prompts and clinical information
+from prompts import DR_CLINICAL_INFO, CONSULTATION_SYSTEM_PROMPT, DEFAULT_QUESTIONS, REPORT_SYSTEM_PROMPT
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger("clarirai-api")
+
+# Store analysis results for later consultation
+analysis_cache = {}
+
+app = FastAPI(
+    title="ClarirAI - Advanced Diabetic Retinopathy Analysis",
+    description="Next-generation API for detecting and analyzing diabetic retinopathy from retinal images with enhanced metrics",
+    version="2.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "https://diabetes-detection-zeta.vercel.app",
+        "https://diabetes-detection-harishvijayasarangank-gmailcoms-projects.vercel.app",
+        "*"  # Allow all origins for development - remove in production
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Enhanced classification labels with descriptions
+labels = {
+    0: {"name": "No DR", "description": "No signs of diabetic retinopathy detected"},
+    1: {"name": "Mild", "description": "Mild nonproliferative diabetic retinopathy"},
+    2: {"name": "Moderate", "description": "Moderate nonproliferative diabetic retinopathy"},
+    3: {"name": "Severe", "description": "Severe nonproliferative diabetic retinopathy"},
+    4: {"name": "Proliferative DR", "description": "Proliferative diabetic retinopathy"},
+}
+
+# Use the imported clinical information instead of defining it here
+dr_clinical_info = DR_CLINICAL_INFO
+
+# Model metadata
+MODEL_INFO = {
+    "name": "ClarirAI Model",
+    "version": "1.2.0",
+    "architecture": "Densenet121",
+    "accuracy": "89.8%",
+    "last_updated": "2025-04-01",
+    "input_size": [224, 224],
+    "color_channels": 3,
+}
+
+# OpenAI/OpenRouter configuration
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+OPENROUTER_API_BASE = "https://openrouter.ai/api/v1"
+OPENROUTER_REFERER = os.environ.get("OPENROUTER_REFERER", "https://clarirai.example.com")
+OPENROUTER_MODEL = os.environ.get("OPENROUTER_MODEL", "mistralai/mistral-7b-instruct")  # Default to a free model
+
+if OPENAI_AVAILABLE and OPENAI_API_KEY:
+    openai.api_key = OPENAI_API_KEY
+    openai.api_base = OPENROUTER_API_BASE
+    logger.info(f"OpenRouter configured with model: {OPENROUTER_MODEL}")
+else:
+    logger.warning("OpenRouter not configured. AI consultation will not be available.")
+
+try:
+    logger.info("Loading ONNX model...")
+    start_time = time.time()
+    session = onnxruntime.InferenceSession('model.onnx')
+    load_time = time.time() - start_time
+    logger.info(f"Model loaded successfully in {load_time:.2f} seconds")
+    MODEL_INFO["load_time_seconds"] = round(load_time, 2)
+except Exception as e:
+    logger.error(f"Error loading model: {e}")
+    session = None  
+
+@app.get("/")
+async def root():
+    """
+    Root endpoint that provides API information
+    """
+    return {
+        "name": "ClarirAI: Advanced Diabetic Retinopathy Analysis API",
+        "version": "2.0.0",
+        "description": "AI-powered diabetic retinopathy detection and analysis with enhanced metrics and consultation",
+        "endpoints": [
+            "/predict", "/health", "/model-info", "/consult", "/generate-report/{analysis_id}"
+        ],
+        "documentation": "/docs"
+    }
+
+@app.get("/health")
+async def health_check():
+    """Check the health status of the API and model"""
+    if session is None:
+        return JSONResponse(
+            status_code=503,
+            content={"status": "unhealthy", "message": "Model failed to load", "timestamp": datetime.now().isoformat()}
+        )
+    return {
+        "status": "healthy",
+        "service": "ClarirAI API",
+        "timestamp": datetime.now().isoformat(),
+        "model_loaded": session is not None
+    }
+
+@app.get("/model-info")
+async def get_model_info():
+    """Get information about the model being used"""
+    if session is None:
+        raise HTTPException(status_code=503, detail="Model not available")
+    
+    return {
+        "name": "ClarirAI Diabetic Retinopathy Classifier",
+        "version": "2.0.0",
+        "framework": "ONNX Runtime",
+        "input_shape": [1, 3, 224, 224],
+        "classes": [labels[i]["name"] for i in labels],
+        "preprocessing": "Resize to 224x224, normalize with ImageNet mean and std"
+    }
+
+def transform_image(image):
+    """Preprocess image for model inference with enhanced normalization"""
+    image = image.resize((224, 224))
+    img_array = np.array(image, dtype=np.float32) / 255.0
+    mean = np.array([0.5353, 0.3628, 0.2486], dtype=np.float32)
+    std = np.array([0.2126, 0.1586, 0.1401], dtype=np.float32)
+    img_array = (img_array - mean) / std
+    img_array = np.transpose(img_array, (2, 0, 1))
+    return np.expand_dims(img_array, axis=0).astype(np.float32)
+
+def calculate_severity_index(probabilities):
+    """Calculate a weighted severity index (0-100) based on class probabilities"""
+    # Weights increase with severity
+    weights = [0, 25, 50, 75, 100]
+    # Convert numpy values to Python native float
+    probs = [float(p) for p in probabilities]
+    severity_index = sum(weights[i] * probs[i] for i in range(5))
+    return round(severity_index, 1)
+
+def get_confidence_level(probability):
+    """Convert probability to a confidence level description"""
+    if probability >= 0.90:
+        return "Very High"
+    elif probability >= 0.75:
+        return "High"
+    elif probability >= 0.50:
+        return "Moderate"
+    elif probability >= 0.25:
+        return "Low"
+    else:
+        return "Very Low"
+
+@app.post("/predict")
+async def predict(file: UploadFile = File(...)):
+    """
+    Predict diabetic retinopathy from retinal image with enhanced metrics
+    
+    - **file**: Upload a retinal image file
+    
+    Returns detailed classification with confidence levels, severity index, and recommendations
+    """
+    analysis_id = str(uuid.uuid4())[:8]  # Generate a unique ID for this analysis
+    logger.info(f"Analysis #{analysis_id}: Received image: {file.filename}, content-type: {file.content_type}")
+    
+    if session is None:
+        raise HTTPException(status_code=503, detail="Model not available")
+    if not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="File provided is not an image")
+    
+    try:
+        # Start timing for performance metrics
+        process_start = time.time()
+        
+        image_data = await file.read()
+        input_img = Image.open(io.BytesIO(image_data)).convert("RGB")
+        input_tensor = transform_image(input_img)
+        input_name = session.get_inputs()[0].name
+        output_name = session.get_outputs()[0].name
+        
+        logger.info(f"Analysis #{analysis_id}: Running inference")
+        inference_start = time.time()
+        prediction = session.run([output_name], {input_name: input_tensor})[0][0]
+        inference_time = time.time() - inference_start
+        
+        exp_preds = np.exp(prediction - np.max(prediction))
+        probabilities = exp_preds / exp_preds.sum()
+        
+        # Convert numpy array to Python list of floats
+        prob_list = [float(p) for p in probabilities]
+        
+        # Calculate severity index
+        severity_index = calculate_severity_index(probabilities)
+        
+        # Format detailed results with confidence levels
+        detailed_results = []
+        for i in labels:
+            prob = float(probabilities[i])  # Convert numpy.float32 to Python float
+            detailed_results.append({
+                "class": labels[i]["name"],
+                "description": labels[i]["description"],
+                "probability": round(prob, 4),
+                "percentage": round(prob * 100, 1),
+                "confidence_level": get_confidence_level(prob)
+            })
+        
+        # Sort by probability (highest first)
+        detailed_results.sort(key=lambda x: x["probability"], reverse=True)
+        highest_class = detailed_results[0]["class"]
+        highest_prob = detailed_results[0]["probability"]
+        
+        # Generate recommendation based on severity
+        recommendation = "Regular screening recommended."
+        if severity_index > 75:
+            recommendation = "Urgent ophthalmologist consultation required."
+        elif severity_index > 50:
+            recommendation = "Prompt ophthalmologist evaluation recommended."
+        elif severity_index > 25:
+            recommendation = "Follow-up with ophthalmologist advised."
+        
+        # Get clinical information for the highest probability class
+        clinical_info = dr_clinical_info.get(highest_class, {})
+        
+        # Calculate binary classification (DR vs No DR)
+        dr_probability = sum(float(probabilities[i]) for i in range(1, 5))  # Sum of all DR classes, convert to Python float
+        binary_classification = {
+            "no_dr": float(probabilities[0]),  # Convert to Python float
+            "dr_detected": float(dr_probability),
+            "primary_assessment": "DR Detected" if dr_probability > float(probabilities[0]) else "No DR"
+        }
+        
+        # Get suggested questions and generate answers if OpenAI is available
+        suggested_questions = clinical_info.get("suggested_questions", [])
+        question_answers = []
+        
+        if OPENAI_AVAILABLE and OPENAI_API_KEY and suggested_questions:
+            try:
+                # Create an OpenAI client
+                client = openai.OpenAI(
+                    api_key=OPENAI_API_KEY,
+                    base_url=OPENROUTER_API_BASE,
+                    default_headers={"HTTP-Referer": OPENROUTER_REFERER}
+                )
+                
+                # Prepare context for the AI
+                context = f"""Patient Analysis Summary:
+- Diagnosis: {highest_class} (Confidence: {get_confidence_level(highest_prob)})
+- Severity Index: {severity_index}/100
+- Clinical Findings: {clinical_info.get('findings', 'Not available')}
+- Associated Risks: {clinical_info.get('risks', 'Not available')}
+- Standard Recommendations: {clinical_info.get('recommendations', 'Not available')}
+- Standard Follow-up: {clinical_info.get('follow_up', 'Not available')}
+"""
+                
+                # Generate answers for each suggested question
+                for question in suggested_questions:
+                    try:
+                        response = client.chat.completions.create(
+                            model=OPENROUTER_MODEL,
+                            messages=[
+                                {"role": "system", "content": CONSULTATION_SYSTEM_PROMPT}, 
+                                {"role": "user", "content": f"{context}\n\nPatient Question: {question}"}
+                            ]
+                        )
+                        
+                        answer = response.choices[0].message.content
+                        question_answers.append({
+                            "question": question,
+                            "answer": answer
+                        })
+                    except Exception as e:
+                        logger.warning(f"Error generating answer for question '{question}': {e}")
+                        question_answers.append({
+                            "question": question,
+                            "answer": "Unable to generate answer at this time. Please try asking this question directly."
+                        })
+            except Exception as e:
+                logger.warning(f"Error generating answers for suggested questions: {e}")
+                # Still include the questions even if answers couldn't be generated
+                question_answers = [{"question": q, "answer": None} for q in suggested_questions]
+        else:
+            # If OpenAI is not available, just include the questions without answers
+            question_answers = [{"question": q, "answer": None} for q in suggested_questions]
+        
+        total_time = time.time() - process_start
+        
+        logger.info(f"Analysis #{analysis_id}: Prediction complete: highest probability class = {highest_class} ({highest_prob:.2f})")
+        
+        # Prepare response
+        response = {
+            "analysis_id": analysis_id,
+            "timestamp": datetime.now().isoformat(),
+            "detailed_classification": detailed_results,
+            "binary_classification": binary_classification,
+            "highest_probability_class": highest_class,
+            "severity_index": severity_index,
+            "recommendation": recommendation,
+            "clinical_information": clinical_info,
+            "ai_explanation": clinical_info.get("explanation", "No explanation available for this classification."),
+            "suggested_questions_with_answers": question_answers,
+            "performance": {
+                "inference_time_ms": round(inference_time * 1000, 2),
+                "total_processing_time_ms": round(total_time * 1000, 2)
+            }
+        }
+        
+        # Cache the analysis result for later consultation
+        analysis_cache[analysis_id] = {
+            "result": response,
+            "image_filename": file.filename,
+            "analysis_time": datetime.now().isoformat()
+        }
+        
+        return response
+        
+    except Exception as e:
+        logger.error(f"Analysis #{analysis_id}: Error processing image: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error processing image: {str(e)}")
+
+@app.get("/analysis/{analysis_id}")
+async def get_analysis(analysis_id: str):
+    """Retrieve a previous analysis by its ID"""
+    if analysis_id not in analysis_cache:
+        raise HTTPException(status_code=404, detail=f"Analysis with ID {analysis_id} not found")
+    
+    return analysis_cache[analysis_id]["result"]
+
+@app.post("/consult")
+async def get_ai_consultation(
+    analysis_id: str = Body(...),
+    question: Optional[str] = Body(None),
+    background_tasks: BackgroundTasks = None
+):
+    """
+    Get AI consultation based on analysis results
+    
+    - analysis_id: ID of the previous analysis
+    - question: Optional specific question about the diagnosis (if not provided, general consultation is given)
+    """
+    if not OPENAI_AVAILABLE or not OPENAI_API_KEY:
+        raise HTTPException(status_code=501, detail="AI consultation feature is not available. OpenAI package or API key not configured.")
+    
+    if analysis_id not in analysis_cache:
+        raise HTTPException(status_code=404, detail=f"Analysis with ID {analysis_id} not found")
+    
+    analysis_data = analysis_cache[analysis_id]["result"]
+    dr_class = analysis_data["highest_probability_class"]
+    severity_index = analysis_data["severity_index"]
+    clinical_info = dr_clinical_info.get(dr_class, {})
+    
+    # Prepare context for the AI
+    context = f"""Patient Analysis Summary:
+- Diagnosis: {dr_class} (Confidence: {get_confidence_level(analysis_data['detailed_classification'][0]['probability'])})
+- Severity Index: {severity_index}/100
+- Clinical Findings: {clinical_info.get('findings', 'Not available')}
+- Associated Risks: {clinical_info.get('risks', 'Not available')}
+- Standard Recommendations: {clinical_info.get('recommendations', 'Not available')}
+- Standard Follow-up: {clinical_info.get('follow_up', 'Not available')}
+"""
+    
+    # Default question if none provided
+    if not question:
+        question = DEFAULT_QUESTIONS["general"].replace("my diagnosis", f"my diagnosis of {dr_class} diabetic retinopathy with a severity index of {severity_index}")
+    
+    try:
+        # Create an OpenAI client with the API key and base URL
+        client = openai.OpenAI(
+            api_key=OPENAI_API_KEY,
+            base_url=OPENROUTER_API_BASE,
+            default_headers={"HTTP-Referer": OPENROUTER_REFERER}
+        )
+        
+        # Call the LLM through OpenRouter using the new API format
+        response = client.chat.completions.create(
+            model=OPENROUTER_MODEL,
+            messages=[
+                {"role": "system", "content": CONSULTATION_SYSTEM_PROMPT}, 
+                {"role": "user", "content": f"{context}\n\nPatient Question: {question}"}
+            ]
+        )
+        
+        # Extract the content from the response using the new API format
+        consultation = response.choices[0].message.content
+        
+        return {
+            "analysis_id": analysis_id,
+            "dr_class": dr_class,
+            "severity_index": severity_index,
+            "question": question,
+            "consultation": consultation,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+    except Exception as e:
+        logger.error(f"Error getting AI consultation: {e}")
+        raise HTTPException(status_code=500, detail=f"Error generating consultation: {str(e)}")
+
+@app.get("/generate-report/{analysis_id}")
+async def generate_report(analysis_id: str, include_consultation: bool = True):
+    """
+    Generate a downloadable medical report based on analysis results
+    
+    - analysis_id: ID of the previous analysis
+    - include_consultation: Whether to include AI consultation in the report
+    """
+    if not DOCX_AVAILABLE:
+        raise HTTPException(status_code=501, detail="Report generation is not available. python-docx package not installed.")
+    
+    if analysis_id not in analysis_cache:
+        raise HTTPException(status_code=404, detail=f"Analysis with ID {analysis_id} not found")
+    
+    analysis_data = analysis_cache[analysis_id]["result"]
+    
+    # Get consultation if requested and available
+    consultation_text = None
+    if include_consultation and OPENAI_AVAILABLE and OPENAI_API_KEY:
+        try:
+            consultation_response = await get_ai_consultation(analysis_id=analysis_id)
+            consultation_text = consultation_response.get("consultation")
+        except Exception as e:
+            logger.warning(f"Could not get consultation for report: {e}")
+    
+    # Generate the report
+    try:
+        doc = Document()
+        
+        # Add header
+        doc.add_heading('ClarirAI Medical Report', 0)
+        doc.add_paragraph(f"Generated on: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        doc.add_paragraph(f"Analysis ID: {analysis_id}")
+        doc.add_paragraph(f"Original Analysis Date: {analysis_data['timestamp']}")
+        
+        # Add diagnosis section
+        doc.add_heading('Diabetic Retinopathy Assessment', level=1)
+        doc.add_paragraph(f"Primary Diagnosis: {analysis_data['highest_probability_class']}")
+        doc.add_paragraph(f"Severity Index: {analysis_data['severity_index']}/100")
+        
+        # Add detailed classification table
+        doc.add_heading('Detailed Classification', level=2)
+        table = doc.add_table(rows=1, cols=4)
+        table.style = 'Table Grid'
+        hdr_cells = table.rows[0].cells
+        hdr_cells[0].text = 'Classification'
+        hdr_cells[1].text = 'Description'
+        hdr_cells[2].text = 'Probability'
+        hdr_cells[3].text = 'Confidence Level'
+        
+        for item in analysis_data['detailed_classification']:
+            row_cells = table.add_row().cells
+            row_cells[0].text = item['class']
+            row_cells[1].text = item['description']
+            row_cells[2].text = f"{item['percentage']}%"
+            row_cells[3].text = item['confidence_level']
+        
+        # Add clinical information
+        dr_class = analysis_data['highest_probability_class']
+        clinical_info = dr_clinical_info.get(dr_class, {})
+        
+        if clinical_info:
+            doc.add_heading('Clinical Information', level=1)
+            doc.add_heading('Findings', level=2)
+            doc.add_paragraph(clinical_info.get('findings', 'Not available'))
+            
+            doc.add_heading('Associated Risks', level=2)
+            doc.add_paragraph(clinical_info.get('risks', 'Not available'))
+            
+            doc.add_heading('Recommendations', level=2)
+            doc.add_paragraph(clinical_info.get('recommendations', 'Not available'))
+            
+            doc.add_heading('Follow-up', level=2)
+            doc.add_paragraph(clinical_info.get('follow_up', 'Not available'))
+        
+        # Add AI explanation
+        doc.add_heading('AI Analysis Explanation', level=1)
+        doc.add_paragraph(clinical_info.get('explanation', 'No explanation available for this classification.'))
+        
+        # Add AI consultation if available
+        if consultation_text:
+            doc.add_heading('AI-Generated Medical Consultation', level=1)
+            doc.add_paragraph(consultation_text)
+        
+        # Add disclaimer
+        doc.add_heading('Disclaimer', level=1)
+        doc.add_paragraph('This report is generated using artificial intelligence and should not replace professional medical advice. The analysis and recommendations provided are based on automated image processing and AI consultation. Please consult with a qualified healthcare provider for proper diagnosis, treatment, and follow-up care.')
+        
+        # Save to temp file
+        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".docx")
+        doc.save(temp_file.name)
+        temp_file.close()
+        
+        return FileResponse(
+            path=temp_file.name,
+            filename=f"ClarirAI_Report_{analysis_id}.docx",
+            media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+        )
+        
+    except Exception as e:
+        logger.error(f"Error generating report: {e}")
+        raise HTTPException(status_code=500, detail=f"Error generating report: {str(e)}")
+
+# Run the server
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=True)

model.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b2df12f77e5a9240ad729d61a4e63c0304cb232bc99f47c4a166c2330efa0780
+size 28227960

prompts.py

@@ -0,0 +1,91 @@
+# ClarirAI - System Prompts and Questions
+
+# System prompt for AI consultation
+CONSULTATION_SYSTEM_PROMPT = """
+You are ClarirAI's medical consultation assistant specializing in diabetic retinopathy. 
+Provide clear, accurate, and personalized information about DR diagnosis, treatment options, and management strategies. 
+Base your response on the specific diagnosis and clinical information provided. 
+Include both medical facts and supportive guidance. 
+Always remind the patient that this is AI-generated advice and they should consult with their healthcare provider.
+"""
+
+# Clinical information and suggested questions for each DR stage
+DR_CLINICAL_INFO = {
+    "No DR": {
+        "findings": "No visible abnormalities in the retina.",
+        "risks": "Low risk for vision loss, but continued monitoring is important for diabetic patients.",
+        "recommendations": "Annual eye examination. Maintain good blood sugar control, blood pressure, and cholesterol levels.",
+        "follow_up": "Routine annual diabetic eye screening.",
+        "explanation": "The model has classified this image as showing no signs of diabetic retinopathy. This means the retinal image appears normal without microaneurysms, hemorrhages, exudates, or other abnormalities typically associated with diabetic eye disease. The blood vessels appear normal in caliber and pattern.",
+        "suggested_questions": [
+            "What preventive measures should I take to maintain my eye health with diabetes?",
+            "How often should I get my eyes checked given my current status?",
+            "What early symptoms should I watch for that might indicate developing diabetic retinopathy?"
+        ]
+    },
+    "Mild": {
+        "findings": "Microaneurysms (small areas of balloon-like swelling in the retina's tiny blood vessels).",
+        "risks": "Low risk for vision loss in the short term, but indicates progression of diabetes affecting the eyes.",
+        "recommendations": "Improve glycemic control. Monitor blood pressure and cholesterol levels. Consider lifestyle modifications.",
+        "follow_up": "Eye examination every 6-12 months depending on other risk factors.",
+        "explanation": "The model has detected mild nonproliferative diabetic retinopathy in this image. This early stage is characterized by the presence of at least one microaneurysm (small swelling in the retina's blood vessels). At this stage, the condition typically doesn't affect vision, but it indicates that diabetes is beginning to damage the eye's blood vessels.",
+        "suggested_questions": [
+            "What lifestyle changes would be most effective to prevent my condition from progressing?",
+            "How quickly can mild diabetic retinopathy progress to more severe stages?",
+            "Are there specific dietary recommendations that could help my condition?"
+        ]
+    },
+    "Moderate": {
+        "findings": "More microaneurysms, dot and blot hemorrhages, venous beading, and/or cotton wool spots.",
+        "risks": "Moderate risk for vision loss. Indicates progressive damage to the retina.",
+        "recommendations": "Strict glycemic control. Blood pressure management. Possible referral to endocrinologist for diabetes management optimization.",
+        "follow_up": "Eye examination every 4-6 months. Possible additional testing such as OCT or fluorescein angiography.",
+        "explanation": "The model has identified moderate nonproliferative diabetic retinopathy in this image. This stage shows increased retinal damage with multiple microaneurysms, dot and blot hemorrhages (small spots of blood leaking into the retina), and potentially cotton wool spots (areas of retinal nerve fiber layer infarction). Venous beading (irregularity in vein diameter) may also be present. These changes indicate more significant vascular damage from diabetes.",
+        "suggested_questions": [
+            "What treatment options should I consider at this stage of diabetic retinopathy?",
+            "How might this condition affect my vision in the near future?",
+            "What specific blood sugar targets should I aim for to slow the progression?"
+        ]
+    },
+    "Severe": {
+        "findings": "Substantial intraretinal hemorrhages, definite venous beading, and prominent intraretinal microvascular abnormalities (IRMA).",
+        "risks": "High risk for vision loss. Significant retinal damage present.",
+        "recommendations": "Urgent ophthalmologist consultation. Aggressive management of diabetes and other risk factors.",
+        "follow_up": "Frequent monitoring every 2-4 months by an ophthalmologist. Possible preparation for intervention.",
+        "explanation": "The model has detected severe nonproliferative diabetic retinopathy in this image. This advanced stage shows extensive vascular damage with numerous hemorrhages in all four quadrants of the retina, prominent venous beading, and intraretinal microvascular abnormalities (IRMA). At this stage, the retina is severely compromised, and there is a high risk of progression to proliferative diabetic retinopathy within a year if not treated.",
+        "suggested_questions": [
+            "What urgent interventions should I consider to prevent further vision loss?",
+            "Am I at immediate risk for blindness, and what can be done to prevent it?",
+            "How will this condition affect my daily activities and independence?"
+        ]
+    },
+    "Proliferative DR": {
+        "findings": "Neovascularization (growth of new abnormal blood vessels), potential vitreous hemorrhage or retinal detachment.",
+        "risks": "Very high risk for severe vision loss or blindness without treatment.",
+        "recommendations": "Immediate referral for ophthalmological intervention. Possible laser photocoagulation, anti-VEGF injections, or vitrectomy.",
+        "follow_up": "Frequent specialized ophthalmological care. Post-treatment monitoring schedule as determined by specialist.",
+        "explanation": "The model has identified proliferative diabetic retinopathy in this image, the most advanced stage of the disease. This is characterized by neovascularization - the growth of abnormal new blood vessels on the surface of the retina or optic disc. These fragile vessels can easily rupture and bleed into the vitreous (gel-like substance in the eye), causing sudden vision loss. There may also be signs of previous treatments like laser scars if intervention has already occurred.",
+        "suggested_questions": [
+            "What immediate surgical or laser treatments do I need to consider?",
+            "What is the likelihood of regaining vision that has been lost?",
+            "How will ongoing treatment affect my quality of life and what support systems should I put in place?"
+        ]
+    }
+}
+
+# Default questions for each severity level
+DEFAULT_QUESTIONS = {
+    "general": "Based on my diagnosis, what should I know about my condition and what steps should I take?",
+    "lifestyle": "What lifestyle changes would be most beneficial for my specific condition?",
+    "prognosis": "What is the likely progression of my condition if I follow all medical recommendations?",
+    "treatment": "What are the current best treatment options for my condition?"
+}
+
+# Report generation system prompt
+REPORT_SYSTEM_PROMPT = """
+You are ClarirAI's medical report assistant specializing in diabetic retinopathy.
+Your role is to generate professional medical report content based on diabetic retinopathy analysis.
+Include all relevant clinical information, findings, and recommendations.
+Use professional medical terminology but ensure explanations are clear enough for patients to understand.
+Clearly mark any sections that require follow-up or urgent attention.
+"""

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+onnxruntime
+numpy
+pillow
+python-multipart
+openai
+python-docx
+python-dotenv