Add comprehensive LLM endpoints and enhance FastAPI backend

- Add Google Gemini AI integration for chat and report generation
- Implement /api/chat endpoint for conversational AI assistant
- Implement /api/generate-report endpoint for automated report generation
- Add Pydantic models for request validation
- Update health check endpoint to show AI model and LLM status
- Add google-generativeai and python-dotenv to requirements
- Create .env.example template for environment variables
- Add comprehensive API documentation (API_DOCUMENTATION.md)
- Create test_api.py script for endpoint testing
- Update .gitignore to exclude .env files
- Support both GEMINI_API_KEY and VITE_GEMINI_API_KEY env vars

.env.example

@@ -0,0 +1,7 @@
+# Gemini API Key for LLM functionality
+# Get your API key from: https://makersuite.google.com/app/apikey
+GEMINI_API_KEY=your_gemini_api_key_here
+VITE_GEMINI_API_KEY=your_gemini_api_key_here
+
+# Optional: Model Configuration
+# GEMINI_MODEL=gemini-1.5-flash

.gitignore

@@ -19,6 +19,11 @@ __pycache__/
 *.pyd
 .venv/
 
+# Environment variables
+.env
+.env.local
+.env.*.local
+
 # Editor directories and files
 .vscode/*
 !.vscode/extensions.json

API_DOCUMENTATION.md

@@ -0,0 +1,363 @@
+# Pathora Colposcopy API Documentation
+
+## Overview
+FastAPI backend for Pathora Colposcopy Assistant with AI model inference and LLM capabilities.
+
+## Base URL
+- Local: `http://localhost:8000`
+- Production: `https://huggingface.co/spaces/ManalifeAI/Pathora_Colposcopy_Assistant`
+
+---
+
+## Endpoints
+
+### Health Check
+**GET** `/health`
+
+Check API health status and verify AI models and LLM availability.
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "service": "Pathora Colposcopy API",
+  "ai_models": {
+    "acetowhite_model": "loaded",
+    "cervix_model": "loaded"
+  },
+  "llm": {
+    "gemini_available": true,
+    "api_key_configured": true
+  }
+}
+```
+
+---
+
+## AI Model Endpoints
+
+### 1. Acetowhite Contour Detection
+**POST** `/api/infer-aw-contour`
+
+Detect acetowhite lesions and generate contour overlays.
+
+**Parameters:**
+- `file` (UploadFile): Image file
+- `conf_threshold` (float, optional): Confidence threshold (0.0-1.0, default: 0.4)
+
+**Response:**
+```json
+{
+  "status": "success",
+  "message": "Inference completed successfully",
+  "result_image": "base64_encoded_image",
+  "contours": [
+    {
+      "points": [[x1, y1], [x2, y2], ...],
+      "area": 1234.5,
+      "confidence": 0.85
+    }
+  ],
+  "detections": 2,
+  "confidence_threshold": 0.4
+}
+```
+
+### 2. Cervix Bounding Box Detection
+**POST** `/api/infer-cervix-bbox`
+
+Detect cervix location and return bounding boxes.
+
+**Parameters:**
+- `file` (UploadFile): Image file
+- `conf_threshold` (float, optional): Confidence threshold (0.0-1.0, default: 0.4)
+
+**Response:**
+```json
+{
+  "status": "success",
+  "message": "Cervix bounding box detection completed",
+  "result_image": "base64_encoded_image",
+  "bounding_boxes": [
+    {
+      "x1": 100,
+      "y1": 150,
+      "x2": 400,
+      "y2": 450,
+      "confidence": 0.92,
+      "class": "cervix"
+    }
+  ],
+  "detections": 1,
+  "frame_width": 1920,
+  "frame_height": 1080,
+  "confidence_threshold": 0.4
+}
+```
+
+### 3. Batch Image Inference
+**POST** `/api/batch-infer`
+
+Process multiple images for acetowhite detection in one request.
+
+**Parameters:**
+- `files` (List[UploadFile]): Multiple image files
+- `conf_threshold` (float, optional): Confidence threshold (default: 0.4)
+
+**Response:**
+```json
+{
+  "status": "completed",
+  "total_files": 3,
+  "results": [
+    {
+      "filename": "image1.jpg",
+      "status": "success",
+      "result_image": "base64...",
+      "contours": [...],
+      "detections": 2
+    }
+  ]
+}
+```
+
+### 4. Single Frame Analysis
+**POST** `/infer/image`
+
+Analyze single image for cervix quality assessment.
+
+**Parameters:**
+- `file` (UploadFile): Image file
+
+**Response:**
+```json
+{
+  "status": "Excellent",
+  "quality_percent": 95,
+  "cervix_detected": true,
+  "focus_score": 0.89,
+  "brightness_score": 0.92
+}
+```
+
+### 5. Video Frame Analysis
+**POST** `/infer/video`
+
+Process video frames for quality assessment.
+
+**Parameters:**
+- `file` (UploadFile): Video file
+
+**Response:**
+```json
+{
+  "total_frames": 150,
+  "results": [
+    {
+      "frame": 0,
+      "status": "Excellent",
+      "quality_percent": 95
+    }
+  ]
+}
+```
+
+---
+
+## LLM Endpoints
+
+### 6. Chat with AI Assistant
+**POST** `/api/chat`
+
+Conversational AI endpoint for colposcopy guidance.
+
+**Request Body:**
+```json
+{
+  "message": "What are the signs of high-grade lesions?",
+  "history": [
+    {
+      "role": "user",
+      "text": "Hello"
+    },
+    {
+      "role": "bot",
+      "text": "Hello! I'm Pathora AI..."
+    }
+  ],
+  "system_prompt": "Optional custom system prompt"
+}
+```
+
+**Response:**
+```json
+{
+  "status": "success",
+  "response": "High-grade lesions typically show...",
+  "model": "gemini-1.5-flash"
+}
+```
+
+### 7. Generate Colposcopy Report
+**POST** `/api/generate-report`
+
+Generate comprehensive colposcopy report based on patient data and findings.
+
+**Request Body:**
+```json
+{
+  "patient_data": {
+    "age": 35,
+    "gravida": 2,
+    "para": 2,
+    "lmp": "2024-02-01",
+    "indication": "Abnormal Pap smear"
+  },
+  "exam_findings": {
+    "native": {
+      "cervix_visible": true,
+      "transformation_zone": "Type 1"
+    },
+    "acetic_acid": {
+      "acetowhite_lesions": true,
+      "location": "6-9 o'clock"
+    },
+    "green_filter": {
+      "vascular_patterns": "Punctation"
+    },
+    "lugol": {
+      "iodine_uptake": "Partial"
+    }
+  },
+  "images": [],
+  "system_prompt": "Optional custom prompt"
+}
+```
+
+**Response:**
+```json
+{
+  "status": "success",
+  "report": "COLPOSCOPY REPORT\n\nCLINICAL SUMMARY:\n...",
+  "model": "gemini-1.5-flash"
+}
+```
+
+---
+
+## Environment Variables
+
+Required for LLM functionality:
+
+```bash
+GEMINI_API_KEY=your_api_key_here
+VITE_GEMINI_API_KEY=your_api_key_here  # For frontend compatibility
+```
+
+Get your API key from: https://makersuite.google.com/app/apikey
+
+---
+
+## Error Responses
+
+All endpoints return standardized error responses:
+
+```json
+{
+  "detail": "Error message description"
+}
+```
+
+**Common HTTP Status Codes:**
+- `400`: Bad Request (invalid file, parameters)
+- `500`: Internal Server Error (AI model error, processing failure)
+- `503`: Service Unavailable (LLM not configured, API key missing)
+
+---
+
+## Model Information
+
+### AI Models
+- **Acetowhite Detection**: YOLO-based segmentation model (`AW_yolo.pt`)
+- **Cervix Detection**: YOLO-based object detection model (`cervix_yolo.pt`)
+
+### LLM Model
+- **Gemini 1.5 Flash**: Google's generative AI for chat and report generation
+  - Temperature: 0.4 (balanced between creativity and consistency)
+  - Max Output Tokens: 2048
+
+---
+
+## Usage Examples
+
+### Python
+```python
+import requests
+
+# AI Model Inference
+with open('image.jpg', 'rb') as f:
+    response = requests.post(
+        'http://localhost:8000/api/infer-aw-contour',
+        files={'file': f},
+        data={'conf_threshold': 0.5}
+    )
+    result = response.json()
+
+# Chat
+response = requests.post(
+    'http://localhost:8000/api/chat',
+    json={
+        'message': 'What is Reid colposcopic index?',
+        'history': []
+    }
+)
+chat_result = response.json()
+```
+
+### JavaScript/TypeScript
+```typescript
+// AI Model Inference
+const formData = new FormData();
+formData.append('file', imageFile);
+formData.append('conf_threshold', '0.5');
+
+const response = await fetch('/api/infer-aw-contour', {
+  method: 'POST',
+  body: formData
+});
+const result = await response.json();
+
+// Chat
+const chatResponse = await fetch('/api/chat', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    message: 'Explain transformation zone types',
+    history: []
+  })
+});
+const chatResult = await chatResponse.json();
+```
+
+---
+
+## Development
+
+### Running Locally
+```bash
+# Install dependencies
+cd backend
+pip install -r requirements.txt
+
+# Set environment variables
+export GEMINI_API_KEY=your_key
+
+# Run server
+uvicorn backend.app:app --reload --host 0.0.0.0 --port 8000
+```
+
+### Building with Docker
+```bash
+docker build -t pathora-colpo .
+docker run -p 7860:7860 -e GEMINI_API_KEY=your_key pathora-colpo
+```

backend/app.py

@@ -1,7 +1,8 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi import FastAPI, File, UploadFile, HTTPException, Body
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
 import cv2
 import numpy as np
 import tempfile
@@ -10,8 +11,18 @@ from io import BytesIO
 from PIL import Image
 import uvicorn
 import traceback
+import json
+from typing import List, Dict, Optional
 from .inference import infer_aw_contour, analyze_frame, analyze_video_frame, infer_cervix_bbox
 
+# Import Google Gemini (optional - graceful degradation if not installed)
+try:
+    import google.generativeai as genai
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+    print("⚠️  google-generativeai not installed. LLM endpoints will be unavailable.")
+
 app = FastAPI(title="Pathora Colposcopy API", version="1.0.0")
 
 # Add CORS middleware to allow requests from frontend
@@ -23,6 +34,34 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Initialize Gemini if available
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY") or os.getenv("VITE_GEMINI_API_KEY")
+if GEMINI_AVAILABLE and GEMINI_API_KEY:
+    try:
+        genai.configure(api_key=GEMINI_API_KEY)
+        print("✅ Gemini AI configured successfully")
+    except Exception as e:
+        print(f"⚠️  Failed to configure Gemini: {e}")
+        GEMINI_AVAILABLE = False
+elif GEMINI_AVAILABLE:
+    print("⚠️  GEMINI_API_KEY not found in environment variables")
+
+# Pydantic models for LLM endpoints
+class ChatMessage(BaseModel):
+    role: str
+    text: str
+
+class ChatRequest(BaseModel):
+    message: str
+    history: List[ChatMessage] = []
+    system_prompt: Optional[str] = None
+
+class ReportGenerationRequest(BaseModel):
+    patient_data: Dict
+    exam_findings: Dict
+    images: Optional[List[str]] = []  # base64 encoded images
+    system_prompt: Optional[str] = None
+
 
 class SPAStaticFiles(StaticFiles):
     async def get_response(self, path: str, scope):
@@ -35,7 +74,148 @@ class SPAStaticFiles(StaticFiles):
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""
-    return {"status": "healthy", "service": "Pathora Colposcopy API"}
+    return {
+        "status": "healthy", 
+        "service": "Pathora Colposcopy API",
+        "ai_models": {
+            "acetowhite_model": "loaded",
+            "cervix_model": "loaded"
+        },
+        "llm": {
+            "gemini_available": GEMINI_AVAILABLE,
+            "api_key_configured": bool(GEMINI_API_KEY)
+        }
+    }
+
+
+@app.post("/api/chat")
+async def chat_endpoint(request: ChatRequest):
+    """
+    LLM Chat endpoint for conversational AI assistant
+    
+    Args:
+        request: ChatRequest with message, history, and optional system_prompt
+    
+    Returns:
+        JSON with AI response
+    """
+    if not GEMINI_AVAILABLE:
+        raise HTTPException(
+            status_code=503, 
+            detail="Gemini AI is not available. Install google-generativeai package."
+        )
+    
+    if not GEMINI_API_KEY:
+        raise HTTPException(
+            status_code=503,
+            detail="GEMINI_API_KEY not configured in environment variables"
+        )
+    
+    try:
+        # Use system prompt or default
+        system_prompt = request.system_prompt or """You are Pathora AI — a specialist colposcopy assistant. \
+Provide expert guidance on examination techniques, findings interpretation, and management guidelines. \
+Be professional, evidence-based, and concise."""
+        
+        # Initialize Gemini model
+        model = genai.GenerativeModel(
+            model_name="gemini-1.5-flash",
+            system_instruction=system_prompt
+        )
+        
+        # Build conversation history
+        chat_history = []
+        for msg in request.history:
+            role = "model" if msg.role == "bot" else "user"
+            chat_history.append({
+                "role": role,
+                "parts": [msg.text]
+            })
+        
+        # Start chat with history
+        chat = model.start_chat(history=chat_history)
+        
+        # Send message and get response
+        response = chat.send_message(request.message)
+        
+        return JSONResponse({
+            "status": "success",
+            "response": response.text,
+            "model": "gemini-1.5-flash"
+        })
+    
+    except Exception as e:
+        print(f"❌ Chat error: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Chat error: {str(e)}")
+
+
+@app.post("/api/generate-report")
+async def generate_report_endpoint(request: ReportGenerationRequest):
+    """
+    Generate colposcopy report using LLM based on patient data and exam findings
+    
+    Args:
+        request: ReportGenerationRequest with patient data, exam findings, and images
+    
+    Returns:
+        JSON with generated report
+    """
+    if not GEMINI_AVAILABLE:
+        raise HTTPException(
+            status_code=503,
+            detail="Gemini AI is not available. Install google-generativeai package."
+        )
+    
+    if not GEMINI_API_KEY:
+        raise HTTPException(
+            status_code=503,
+            detail="GEMINI_API_KEY not configured in environment variables"
+        )
+    
+    try:
+        # Use system prompt or default
+        system_prompt = request.system_prompt or """You are an expert colposcopy AI assistant acting as a specialist gynaecologist.
+Analyse ALL the clinical data and the attached colposcopy images to generate a professional, evidence-based colposcopy report conclusion."""
+        
+        # Build prompt with patient data and findings
+        prompt_parts = []
+        
+        # Add patient data
+        prompt_parts.append("PATIENT DATA:")
+        prompt_parts.append(json.dumps(request.patient_data, indent=2))
+        
+        # Add exam findings
+        prompt_parts.append("\nEXAMINATION FINDINGS:")
+        prompt_parts.append(json.dumps(request.exam_findings, indent=2))
+        
+        # Add instruction
+        prompt_parts.append("\nBased on the above data, generate a professional colposcopy report with:")
+        prompt_parts.append("1. Summary of findings")
+        prompt_parts.append("2. Clinical impression")
+        prompt_parts.append("3. Recommendations")
+        
+        full_prompt = "\n".join(prompt_parts)
+        
+        # Initialize model
+        model = genai.GenerativeModel(
+            model_name="gemini-1.5-flash",
+            system_instruction=system_prompt
+        )
+        
+        # Generate report
+        response = model.generate_content(full_prompt)
+        
+        return JSONResponse({
+            "status": "success",
+            "report": response.text,
+            "model": "gemini-1.5-flash"
+        })
+    
+    except Exception as e:
+        print(f"❌ Report generation error: {e}")
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Report generation error: {str(e)}")
 
 
 @app.post("/api/infer-aw-contour")

backend/requirements.txt

@@ -8,3 +8,6 @@ ultralytics
 pillow==10.2.0
 python-multipart==0.0.6
 setuptools>=69.0.0
+google-generativeai>=0.3.0
+python-dotenv>=1.0.0
+pydantic>=2.0.0

backend/test_api.py

@@ -0,0 +1,275 @@
+"""
+Test script for Pathora Colposcopy API endpoints
+Demonstrates how to use both AI model and LLM endpoints
+"""
+
+import requests
+import json
+import base64
+from pathlib import Path
+
+# API Configuration
+BASE_URL = "http://localhost:8000"  # Change to your deployment URL
+API_KEY = "your_gemini_api_key_here"  # For local testing
+
+def test_health_check():
+    """Test the health check endpoint"""
+    print("=" * 60)
+    print("Testing Health Check Endpoint")
+    print("=" * 60)
+    
+    response = requests.get(f"{BASE_URL}/health")
+    print(f"Status Code: {response.status_code}")
+    print(f"Response: {json.dumps(response.json(), indent=2)}")
+    print()
+
+def test_acetowhite_detection(image_path: str):
+    """Test acetowhite contour detection"""
+    print("=" * 60)
+    print("Testing Acetowhite Contour Detection")
+    print("=" * 60)
+    
+    with open(image_path, 'rb') as f:
+        files = {'file': f}
+        data = {'conf_threshold': 0.5}
+        
+        response = requests.post(
+            f"{BASE_URL}/api/infer-aw-contour",
+            files=files,
+            data=data
+        )
+    
+    print(f"Status Code: {response.status_code}")
+    result = response.json()
+    
+    # Print without base64 image for readability
+    print(f"Status: {result.get('status')}")
+    print(f"Detections: {result.get('detections')}")
+    print(f"Contours: {len(result.get('contours', []))}")
+    print(f"Confidence Threshold: {result.get('confidence_threshold')}")
+    
+    # Save result image if available
+    if result.get('result_image'):
+        output_path = "test_output_aw.png"
+        img_data = base64.b64decode(result['result_image'])
+        with open(output_path, 'wb') as f:
+            f.write(img_data)
+        print(f"Result image saved to: {output_path}")
+    print()
+
+def test_cervix_detection(image_path: str):
+    """Test cervix bounding box detection"""
+    print("=" * 60)
+    print("Testing Cervix Bounding Box Detection")
+    print("=" * 60)
+    
+    with open(image_path, 'rb') as f:
+        files = {'file': f}
+        data = {'conf_threshold': 0.4}
+        
+        response = requests.post(
+            f"{BASE_URL}/api/infer-cervix-bbox",
+            files=files,
+            data=data
+        )
+    
+    print(f"Status Code: {response.status_code}")
+    result = response.json()
+    
+    print(f"Status: {result.get('status')}")
+    print(f"Detections: {result.get('detections')}")
+    print(f"Bounding Boxes: {json.dumps(result.get('bounding_boxes', []), indent=2)}")
+    
+    # Save result image if available
+    if result.get('result_image'):
+        output_path = "test_output_cervix.png"
+        img_data = base64.b64decode(result['result_image'])
+        with open(output_path, 'wb') as f:
+            f.write(img_data)
+        print(f"Result image saved to: {output_path}")
+    print()
+
+def test_batch_inference(image_paths: list):
+    """Test batch inference on multiple images"""
+    print("=" * 60)
+    print("Testing Batch Inference")
+    print("=" * 60)
+    
+    files = [('files', open(img, 'rb')) for img in image_paths]
+    data = {'conf_threshold': 0.5}
+    
+    response = requests.post(
+        f"{BASE_URL}/api/batch-infer",
+        files=files,
+        data=data
+    )
+    
+    # Close file handles
+    for _, f in files:
+        f.close()
+    
+    print(f"Status Code: {response.status_code}")
+    result = response.json()
+    
+    print(f"Status: {result.get('status')}")
+    print(f"Total Files: {result.get('total_files')}")
+    
+    for i, res in enumerate(result.get('results', [])):
+        print(f"\nImage {i+1}: {res.get('filename')}")
+        print(f"  Status: {res.get('status')}")
+        print(f"  Detections: {res.get('detections')}")
+    print()
+
+def test_chat():
+    """Test LLM chat endpoint"""
+    print("=" * 60)
+    print("Testing Chat Endpoint")
+    print("=" * 60)
+    
+    payload = {
+        "message": "What are the typical signs of a high-grade squamous intraepithelial lesion (HSIL) on colposcopy?",
+        "history": []
+    }
+    
+    response = requests.post(
+        f"{BASE_URL}/api/chat",
+        json=payload
+    )
+    
+    print(f"Status Code: {response.status_code}")
+    
+    if response.status_code == 200:
+        result = response.json()
+        print(f"Status: {result.get('status')}")
+        print(f"Model: {result.get('model')}")
+        print(f"Response:\n{result.get('response')}")
+    else:
+        print(f"Error: {response.json()}")
+    print()
+
+def test_chat_with_history():
+    """Test chat with conversation history"""
+    print("=" * 60)
+    print("Testing Chat with History")
+    print("=" * 60)
+    
+    payload = {
+        "message": "What about low-grade lesions?",
+        "history": [
+            {
+                "role": "user",
+                "text": "What are high-grade lesions?"
+            },
+            {
+                "role": "bot",
+                "text": "High-grade lesions (HSIL) show dense acetowhite epithelium, coarse punctation, and sharp borders."
+            }
+        ]
+    }
+    
+    response = requests.post(
+        f"{BASE_URL}/api/chat",
+        json=payload
+    )
+    
+    print(f"Status Code: {response.status_code}")
+    
+    if response.status_code == 200:
+        result = response.json()
+        print(f"Response:\n{result.get('response')}")
+    else:
+        print(f"Error: {response.json()}")
+    print()
+
+def test_report_generation():
+    """Test report generation endpoint"""
+    print("=" * 60)
+    print("Testing Report Generation")
+    print("=" * 60)
+    
+    payload = {
+        "patient_data": {
+            "age": 35,
+            "gravida": 2,
+            "para": 2,
+            "lmp": "2024-02-01",
+            "indication": "Abnormal Pap smear - ASCUS",
+            "menstrual_status": "Regular"
+        },
+        "exam_findings": {
+            "native": {
+                "cervix_visible": True,
+                "transformation_zone": "Type 1 (fully visible)",
+                "ectropion": "Mild",
+                "discharge": "None"
+            },
+            "acetic_acid": {
+                "acetowhite_lesions": True,
+                "location": "6-9 o'clock position",
+                "density": "Dense white",
+                "borders": "Sharp, well-defined",
+                "size": "Moderate (covering 2 quadrants)"
+            },
+            "green_filter": {
+                "vascular_patterns": "Coarse punctation",
+                "mosaic": "Present",
+                "atypical_vessels": "None"
+            },
+            "lugol": {
+                "iodine_uptake": "Partial iodine negative area",
+                "pattern": "Corresponds to acetowhite area"
+            }
+        }
+    }
+    
+    response = requests.post(
+        f"{BASE_URL}/api/generate-report",
+        json=payload
+    )
+    
+    print(f"Status Code: {response.status_code}")
+    
+    if response.status_code == 200:
+        result = response.json()
+        print(f"Status: {result.get('status')}")
+        print(f"Model: {result.get('model')}")
+        print(f"\nGenerated Report:\n{'-' * 60}")
+        print(result.get('report'))
+        print('-' * 60)
+    else:
+        print(f"Error: {response.json()}")
+    print()
+
+def main():
+    """Run all tests"""
+    print("\n" + "=" * 60)
+    print("PATHORA COLPOSCOPY API TEST SUITE")
+    print("=" * 60 + "\n")
+    
+    # Test health check
+    test_health_check()
+    
+    # Test AI model endpoints (you'll need to provide actual image paths)
+    # Uncomment and add your image paths:
+    # test_acetowhite_detection("path/to/your/image.jpg")
+    # test_cervix_detection("path/to/your/image.jpg")
+    # test_batch_inference(["image1.jpg", "image2.jpg"])
+    
+    # Test LLM endpoints
+    test_chat()
+    test_chat_with_history()
+    test_report_generation()
+    
+    print("\n" + "=" * 60)
+    print("ALL TESTS COMPLETED")
+    print("=" * 60 + "\n")
+
+if __name__ == "__main__":
+    # Check if requests is installed
+    try:
+        import requests
+    except ImportError:
+        print("Please install requests: pip install requests")
+        exit(1)
+    
+    main()