Updated Lab Report Analysis AI with Gradio interface and Google AI Studio integration

Dockerfile

@@ -1,23 +1,28 @@
-FROM python:3.9
+# Use Python 3.11 slim image
+FROM python:3.11-slim
 
 # Set working directory
-WORKDIR /code
+WORKDIR /app
 
-# Copy requirements first for better caching
-COPY ./requirements.txt /code/requirements.txt
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    && rm -rf /var/lib/apt/lists/*
 
-# Install dependencies
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy application code
-COPY . /code
+# Copy application files
+COPY . .
 
-# Expose port 7860 (required by Hugging Face Spaces)
+# Expose port
 EXPOSE 7860
 
-# Set environment variables
-ENV PYTHONPATH=/code
-ENV HUGGINGFACE_API_KEY=${HUGGINGFACE_API_KEY}
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health
 
-# Command to run the application
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
+# Run the application
+CMD ["python", "app.py"]

README.md

@@ -1,272 +1,88 @@
 ---
-title: GP-Tea Lab Analysis
-emoji: 🧪
+title: Lab Report Analysis AI
+emoji: 🏥
 colorFrom: blue
 colorTo: green
-sdk: docker
-app_port: 7860
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
 pinned: false
 license: apache-2.0
+short_description: AI-powered lab report analysis using Google AI Studio
 ---
 
-# GP-Tea Lab Analysis Service
+# 🏥 Lab Report Analysis AI
 
-A FastAPI-based web service for analyzing lab report images using AI. This service accepts lab report images and provides structured medical analysis with key findings, interpretations, and health insights.
+An intelligent lab report analysis system that uses Google AI Studio's Gemini model to analyze medical lab reports and provide structured interpretations.
 
-## Features
+## ✨ Features
 
-- 🖼️ Image upload support (JPG, PNG, BMP, TIFF, WEBP)
-- 🔍 AI-powered lab report analysis
-- 📊 Structured response with summary, key findings, and interpretation
-- 🌐 RESTful API with automatic documentation
-- 🧪 Built-in test client and web interface
-- ⚡ Async processing for better performance
+- 📸 **Image Analysis**: Upload lab report images in various formats (JPG, PNG, TIFF, etc.)
+- 🤖 **AI-Powered**: Uses Google's Gemini 2.0 Flash model for accurate analysis
+- 📊 **Structured Output**: Provides organized summary, key findings, and interpretations
+- ⚡ **Fast Processing**: Quick analysis with real-time results
+- 🔒 **Secure**: Images are processed securely and not stored
+- 🌐 **Web Interface**: Easy-to-use Gradio interface
 
-## Project Structure
+## 🚀 How to Use
 
-```
-Lab_analysis/
-├── main.py                     # FastAPI application
-├── lab_analyzer.py            # Core analysis logic
-├── models.py                  # Pydantic models
-├── test_client.py             # API test client
-├── index.html                 # Web interface
-├── requirements.txt           # Dependencies
-├── Lab_report_analysis.py     # Original script
-└── README.md                  # This file
-```
-
-## Installation
-
-1. **Clone or navigate to the project directory:**
-
-   ```bash
-   cd "e:\E-JUST Assignments\Projects\HealthCare\Lab_analysis"
-   ```
-
-2. **Create a virtual environment (recommended):**
-
-   ```bash
-   python -m venv venv
-   venv\Scripts\activate  # On Windows
-   ```
-
-3. **Install dependencies:**
-   ```bash
-   pip install -r requirements.txt
-   ```
-
-## Running the API
-
-### Method 1: Using Python directly
-
-```bash
-python main.py
-```
-
-### Method 2: Using Uvicorn
+1. **Upload Image**: Click on the upload area and select your lab report image
+2. **Analyze**: Click the "Analyze Report" button
+3. **Review Results**: Get structured analysis with:
+   - Summary of the report
+   - Key findings and abnormal values
+   - Medical interpretation
+   - Important disclaimers
 
-```bash
-uvicorn main:app --host 0.0.0.0 --port 8000 --reload
-```
-
-The API will be available at:
-
-- **API Endpoints**: http://localhost:8000
-- **Interactive Docs**: http://localhost:8000/docs
-- **ReDoc**: http://localhost:8000/redoc
-
-## API Endpoints
-
-### Health Check
+## 🛠️ Technology Stack
 
-- **GET** `/health`
-- Returns service status
+- **Frontend**: Gradio for interactive web interface
+- **Backend**: FastAPI for robust API handling
+- **AI Model**: Google AI Studio (Gemini 2.0 Flash)
+- **Image Processing**: PIL for image handling
+- **Deployment**: Docker containerization for Hugging Face Spaces
 
-### Analyze Lab Report (File Upload)
+## ⚠️ Important Disclaimer
 
-- **POST** `/analyze`
-- Upload an image file for analysis
-- Accepts: `multipart/form-data` with `file` field
+**This tool is for educational and informational purposes only. It should not be used as a substitute for professional medical advice, diagnosis, or treatment. Always consult with qualified healthcare professionals for medical concerns.**
 
-### Analyze Lab Report (Base64)
+## 🏗️ Local Development
 
-- **POST** `/analyze-base64`
-- Send base64 encoded image for analysis
-- Accepts: JSON with `image` field containing base64 string
+### Prerequisites
 
-## Usage Examples
+- Python 3.11+
+- Google AI Studio API key
 
-### Using cURL
-
-1. **Health check:**
+### Installation
 
+1. Clone the repository
+2. Install dependencies:
    ```bash
-   curl http://localhost:8000/health
+   pip install -r requirements.txt
    ```
-
-2. **Analyze image file:**
-
+3. Set your API key:
    ```bash
-   curl -X POST "http://localhost:8000/analyze" \
-        -H "accept: application/json" \
-        -H "Content-Type: multipart/form-data" \
-        -F "file=@your_lab_report.jpg"
+   export GOOGLE_AI_STUDIO_API_KEY=your_api_key_here
    ```
-
-3. **Analyze base64 image:**
+4. Run the application:
    ```bash
-   curl -X POST "http://localhost:8000/analyze-base64" \
-        -H "Content-Type: application/json" \
-        -d '{"image": "your_base64_encoded_image_here"}'
+   python app.py
    ```
 
-### Using Python Test Client
+## 📁 Project Structure
 
-```python
-from test_client import LabReportAPIClient
-
-client = LabReportAPIClient()
-
-# Health check
-health = client.health_check()
-print(health)
-
-# Analyze image
-result = client.analyze_image_file("path/to/your/lab_report.jpg")
-print(result)
 ```
-
-### Using the Web Interface
-
-1. Start the API server
-2. Open `index.html` in your web browser
-3. Drag and drop or select a lab report image
-4. Click "Analyze Report" to get results
-
-## Response Format
-
-Successful analysis returns:
-
-```json
-{
-  "success": true,
-  "filename": "lab_report.jpg",
-  "analysis": {
-    "error": false,
-    "summary": "Brief summary of the lab report",
-    "key_findings": ["Finding 1", "Finding 2", "Finding 3"],
-    "interpretation": "Medical interpretation",
-    "note": "Disclaimer about medical advice",
-    "raw_response": "Complete AI response"
-  }
-}
+├── app.py                 # Main Gradio application
+├── main.py               # FastAPI server
+├── lab_analyzer.py       # Core analysis logic
+├── models.py            # Data models
+├── requirements.txt     # Python dependencies
+├── Dockerfile          # Container configuration
+└── README.md           # Documentation
 ```
 
-## Configuration
-
-### Environment Variables
-
-You can set these environment variables to customize the behavior:
-
-- `API_HOST`: Host to bind to (default: "0.0.0.0")
-- `API_PORT`: Port to bind to (default: 8000)
-- `HF_API_KEY`: Hugging Face API key (currently hardcoded in `lab_analyzer.py`)
-
-### Updating API Key
-
-To use your own Hugging Face API key, modify the `lab_analyzer.py` file:
-
-```python
-self.client = InferenceClient(
-    provider="nebius",
-    api_key="your_api_key_here",  # Replace with your API key
-)
-```
-
-## Development
-
-### Running in Development Mode
-
-```bash
-uvicorn main:app --reload --host 0.0.0.0 --port 8000
-```
-
-### Testing
-
-Run the test client:
-
-```bash
-python test_client.py
-```
-
-### Adding New Features
-
-1. Add new endpoints to `main.py`
-2. Update models in `models.py` if needed
-3. Extend the analyzer in `lab_analyzer.py`
-4. Update documentation
-
-## Deployment
-
-### Docker (Optional)
-
-Create a `Dockerfile`:
-
-```dockerfile
-FROM python:3.9-slim
-
-WORKDIR /app
-COPY requirements.txt .
-RUN pip install -r requirements.txt
-
-COPY . .
-
-EXPOSE 8000
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
-```
-
-Build and run:
-
-```bash
-docker build -t lab-analysis-api .
-docker run -p 8000:8000 lab-analysis-api
-```
-
-### Production Considerations
-
-- Use environment variables for API keys
-- Set up proper CORS origins
-- Add rate limiting
-- Use HTTPS
-- Add authentication if needed
-- Set up logging and monitoring
-
-## Troubleshooting
-
-### Common Issues
-
-1. **Import errors**: Make sure all dependencies are installed
-2. **Port conflicts**: Change the port in the uvicorn command
-3. **API key issues**: Verify your Hugging Face API key is valid
-4. **Image format errors**: Ensure images are in supported formats
-
-### Logs
-
-The application logs important events. Check console output for debugging information.
-
-## License
-
-This project is for educational purposes. Please ensure you have proper licenses for any AI models used.
-
-## Contributing
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Test thoroughly
-5. Submit a pull request
-
----
+## 🙏 Acknowledgments
 
-**Note**: This analysis is for educational purposes only and should not replace professional medical advice.
+- Google AI Studio for providing the Gemini API
+- Hugging Face for Spaces hosting
+- Gradio for the web interface framework

app.py

@@ -1,8 +1,177 @@
+import gradio as gr
+import base64
+import asyncio
 import os
-import uvicorn
-from main import app
+from lab_analyzer import LabReportAnalyzer
+from PIL import Image
+import io
+import logging
 
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize the lab analyzer
+analyzer = LabReportAnalyzer()
+
+async def analyze_lab_report(image):
+    """
+    Analyze a lab report image using the LabReportAnalyzer
+    
+    Args:
+        image: PIL Image from Gradio interface
+        
+    Returns:
+        Formatted analysis results
+    """
+    try:
+        if image is None:
+            return "❌ Please upload an image first."
+        
+        # Convert PIL image to base64
+        buffer = io.BytesIO()
+        image.save(buffer, format="JPEG")
+        image_b64 = base64.b64encode(buffer.getvalue()).decode("utf-8")
+        
+        # Analyze the lab report
+        analysis_result = await analyzer.analyze_report(image_b64)
+        
+        if analysis_result.get("error", False):
+            return f"❌ Error: {analysis_result.get('message', 'Unknown error occurred')}"
+        
+        # Format the results for display
+        formatted_result = f"""
+## 📊 Lab Report Analysis Results
+
+### 📋 Summary
+{analysis_result.get('summary', 'No summary available')}
+
+### 🔍 Key Findings
+"""
+        
+        key_findings = analysis_result.get('key_findings', [])
+        if key_findings:
+            for finding in key_findings:
+                formatted_result += f"• {finding}\n"
+        else:
+            formatted_result += "• No specific findings identified\n"
+        
+        formatted_result += f"""
+### 💡 Interpretation
+{analysis_result.get('interpretation', 'No interpretation available')}
+
+### ⚠️ Important Note
+{analysis_result.get('note', 'This analysis is for educational purposes only and should not replace professional medical advice.')}
+
+---
+*Analysis powered by Google AI Studio (Gemini 2.0 Flash)*
+"""
+        
+        return formatted_result
+        
+    except Exception as e:
+        logger.error(f"Error in analyze_lab_report: {str(e)}")
+        return f"❌ Analysis failed: {str(e)}"
+
+def analyze_wrapper(image):
+    """Wrapper function to run async analysis in Gradio"""
+    return asyncio.run(analyze_lab_report(image))
+
+# Create Gradio interface
+with gr.Blocks(
+    theme=gr.themes.Soft(),
+    title="Lab Report Analysis AI",
+    css="""
+    .gradio-container {
+        max-width: 1200px !important;
+    }
+    .analysis-output {
+        font-family: 'Georgia', serif;
+        line-height: 1.6;
+    }
+    """
+) as demo:
+    
+    gr.Markdown("""
+    # 🏥 Lab Report Analysis AI
+    
+    Upload a lab report image and get an AI-powered analysis with key findings and interpretations.
+    
+    **Features:**
+    - 📸 Image-to-text analysis using advanced AI
+    - 🔍 Structured medical report interpretation
+    - ⚡ Fast and accurate results
+    - 🔒 Secure processing (images are not stored)
+    
+    **Supported formats:** JPG, JPEG, PNG, BMP, TIFF, WEBP
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📤 Upload Lab Report")
+            image_input = gr.Image(
+                type="pil",
+                label="Lab Report Image",
+                height=400
+            )
+            
+            analyze_btn = gr.Button(
+                "🔬 Analyze Report",
+                variant="primary",
+                size="lg"
+            )
+            
+            gr.Markdown("""
+            ### 📝 Instructions:
+            1. Upload a clear image of your lab report
+            2. Click "Analyze Report" button
+            3. Wait for AI analysis results
+            4. Review the structured findings
+            
+            **Note:** This tool is for educational purposes only. 
+            Always consult healthcare professionals for medical advice.
+            """)
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 Analysis Results")
+            analysis_output = gr.Markdown(
+                "Upload an image and click 'Analyze Report' to see results here.",
+                elem_classes=["analysis-output"]
+            )
+    
+    # Event handlers
+    analyze_btn.click(
+        fn=analyze_wrapper,
+        inputs=[image_input],
+        outputs=[analysis_output],
+        show_progress=True
+    )
+    
+    # Example images section
+    gr.Markdown("""
+    ---
+    ### 🎯 Example Lab Reports
+    Try uploading sample lab reports to see how the analysis works!
+    """)
+    
+    # Footer
+    gr.Markdown("""
+    ---
+    **Powered by:**
+    - 🤖 Google AI Studio (Gemini 2.0 Flash)
+    - ⚡ FastAPI Backend
+    - 🎨 Gradio Interface
+    - 🐳 Docker Containerization
+    
+    **Privacy:** Your images are processed securely and not stored permanently.
+    """)
+
+# Launch the app
 if __name__ == "__main__":
-    # Hugging Face Spaces uses port 7860
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+    # For Hugging Face Spaces, use the default port 7860
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )

lab_analyzer.py

@@ -1,26 +1,22 @@
 import base64
-import os
-from huggingface_hub import InferenceClient
+import requests
 import asyncio
 from typing import Dict, Any
 import logging
-from dotenv import load_dotenv
-
-# Load environment variables from .env file
-load_dotenv()
+import json
+import os
 
 logger = logging.getLogger(__name__)
 
 class LabReportAnalyzer:
-    """Lab Report Analysis service using Hugging Face Inference Client"""
+    """Lab Report Analysis service using Google AI Studio API"""
     
     def __init__(self):
-        """Initialize the analyzer with Hugging Face client"""
-        self.client = InferenceClient(
-            token=os.getenv("HUGGINGFACE_API_KEY", "your-api-key-here"),
-
-        )
-        self.model = "google/gemma-3-27b-it"
+        """Initialize the analyzer with Google AI Studio API"""
+        # Try to get API key from environment variable first, fallback to hardcoded
+        self.api_key = os.getenv("GOOGLE_AI_STUDIO_API_KEY", "AIzaSyDZmxLcrroxuxup0cQkXhdVLeU5DsF5Asg")
+        self.base_url = "https://generativelanguage.googleapis.com/v1beta/models"
+        self.model = "gemini-2.0-flash"  # Using Gemini 2.0 Flash for vision capabilities
         
     async def analyze_report(self, image_b64: str) -> Dict[str, Any]:
         """
@@ -45,7 +41,7 @@ class LabReportAnalyzer:
             )
             
             # Extract and parse the response
-            analysis_text = completion.choices[0].message.content.strip()
+            analysis_text = completion.get('candidates', [{}])[0].get('content', {}).get('parts', [{}])[0].get('text', '').strip()
             
             # Parse the structured response
             parsed_result = self._parse_analysis_result(analysis_text)
@@ -61,24 +57,45 @@ class LabReportAnalyzer:
             }
     
     def _run_inference(self, image_b64: str, prompt: str):
-        """Run the Hugging Face inference synchronously"""
-        return self.client.chat.completions.create(
-            model=self.model,
-            messages=[
+        """Run the Google AI Studio API inference synchronously"""
+        url = f"{self.base_url}/{self.model}:generateContent"
+        
+        headers = {
+            "Content-Type": "application/json",
+        }
+        
+        params = {
+            "key": self.api_key
+        }
+        
+        payload = {
+            "contents": [
                 {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": prompt},
+                    "parts": [
+                        {"text": prompt},
                         {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:image/jpeg;base64,{image_b64}"
+                            "inline_data": {
+                                "mime_type": "image/jpeg",
+                                "data": image_b64
                             }
                         }
                     ]
                 }
             ],
-        )
+            "generationConfig": {
+                "temperature": 0.1,
+                "topP": 0.8,
+                "topK": 10,
+                "maxOutputTokens": 2048,
+            }
+        }
+        
+        response = requests.post(url, headers=headers, params=params, json=payload, timeout=30)
+        
+        if response.status_code == 200:
+            return response.json()
+        else:
+            raise Exception(f"API request failed with status {response.status_code}: {response.text}")
     
     def _get_analysis_prompt(self) -> str:
         """Get the structured analysis prompt"""
@@ -141,27 +158,24 @@ Keep it short, clear, and professional — like a medical summary written for qu
                 if not line:
                     continue
                     
-                # Identify sections (handle both plain text and markdown formats)
-                if line.startswith('Summary:') or line.startswith('**Summary:**'):
+                # Identify sections
+                if line.startswith('Summary:'):
                     current_section = 'summary'
-                    result['summary'] = line.replace('**Summary:**', '').replace('Summary:', '').strip()
-                elif line.startswith('Key Findings:') or line.startswith('**Key Findings:**'):
+                    result['summary'] = line.replace('Summary:', '').strip()
+                elif line.startswith('Key Findings:'):
                     current_section = 'key_findings'
-                elif line.startswith('Interpretation:') or line.startswith('**Interpretation:**'):
+                elif line.startswith('Interpretation:'):
                     current_section = 'interpretation'
-                    result['interpretation'] = line.replace('**Interpretation:**', '').replace('Interpretation:', '').strip()
-                elif line.startswith('Note:') or line.startswith('**Note:**'):
+                    result['interpretation'] = line.replace('Interpretation:', '').strip()
+                elif line.startswith('Note:'):
                     current_section = 'note'
-                    result['note'] = line.replace('**Note:**', '').replace('Note:', '').strip()
+                    result['note'] = line.replace('Note:', '').strip()
                 else:
                     # Continue previous section
                     if current_section == 'summary' and not result['summary']:
                         result['summary'] = line
-                    elif current_section == 'key_findings' and (line.startswith(('•', '-', '*')) or line.strip().startswith('*')):
-                        # Handle both regular bullets and markdown-style bullets
-                        clean_line = line.lstrip('•-* ').strip()
-                        if clean_line:
-                            result['key_findings'].append(clean_line)
+                    elif current_section == 'key_findings' and line.startswith(('•', '-', '*')):
+                        result['key_findings'].append(line.lstrip('•-* '))
                     elif current_section == 'interpretation' and not result['interpretation']:
                         result['interpretation'] = line
                     elif current_section == 'note' and not result['note']:

main.py

@@ -6,7 +6,6 @@ import io
 from PIL import Image
 from lab_analyzer import LabReportAnalyzer
 import logging
-import os
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -53,32 +52,27 @@ async def analyze_lab_report(file: UploadFile = File(...)):
         JSON response with analysis results
     """
     try:
-        # Read file contents first
+        # Validate file type
+        if not file.content_type.startswith('image/'):
+            raise HTTPException(
+                status_code=400, 
+                detail="File must be an image (jpg, jpeg, png, bmp, tiff, webp)"
+            )
+        
+        # Read and validate image
         contents = await file.read()
         if len(contents) == 0:
             raise HTTPException(status_code=400, detail="Empty file uploaded")
         
-        # Validate image can be opened (more reliable than content_type)
+        # Validate image can be opened
         try:
             image = Image.open(io.BytesIO(contents))
             image.verify()  # Verify it's a valid image
-            
-            # Reset file pointer for re-reading
-            contents_for_analysis = contents
-            
         except Exception as e:
-            # Check if content type suggests it might be an image
-            allowed_types = ['image/', 'application/octet-stream']
-            if file.content_type and not any(t in file.content_type for t in allowed_types):
-                raise HTTPException(
-                    status_code=400, 
-                    detail=f"File must be an image (jpg, jpeg, png, bmp, tiff, webp). Received: {file.content_type}"
-                )
-            else:
-                raise HTTPException(status_code=400, detail=f"Invalid image file: {str(e)}")
+            raise HTTPException(status_code=400, detail=f"Invalid image file: {str(e)}")
         
         # Convert to base64 for analysis
-        image_b64 = base64.b64encode(contents_for_analysis).decode("utf-8")
+        image_b64 = base64.b64encode(contents).decode("utf-8")
         
         # Analyze the lab report
         logger.info(f"Analyzing lab report: {file.filename}")
@@ -159,6 +153,4 @@ async def analyze_lab_base64_api(data: dict):
 
 if __name__ == "__main__":
     import uvicorn
-    # Use port 7860 for Hugging Face Spaces, fallback to 8000 for local development
-    port = int(os.getenv("PORT", 7860))
-    uvicorn.run("main:app", host="0.0.0.0", port=port, reload=False)
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

requirements.txt

@@ -1,12 +1,9 @@
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-pydantic==2.5.0
-python-multipart==0.0.6
-requests==2.31.0
-python-dotenv==1.0.0
-Pillow==10.0.0
-huggingface-hub==0.24.0
+gradio>=4.0.0
+Pillow>=10.0.0
+numpy>=1.26.0
+requests>=2.31.0
 fastapi>=0.104.0
 uvicorn>=0.24.0
 python-multipart>=0.0.6
-pydantic>=2.4.0
+pydantic>=2.4.0
+aiofiles>=23.1.0