Initial commit

.dockerignore

@@ -0,0 +1,15 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.sqlite3
+.env
+.env.*
+.git/
+.gitignore
+.vscode/
+.idea/
+logs/
+data/
+**/__pycache__/
+**/*.py[cod]

.env

@@ -0,0 +1,10 @@
+# OpenAI Configuration
+OPENAI_API_KEY=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
+
+LANGSMITH_API_KEY=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
+
+LANGSMITH_PROJECT=medical_chatbot
+LANGCHAIN_PROJECT=medical_chatbot
+
+LANGSMITH_URL=https://api.smith.langchain.com
+

.env.example

@@ -0,0 +1,10 @@
+# OpenAI Configuration
+OPENAI_API_KEY=
+OPENAI_BASE_URL=
+
+LANGSMITH_API_KEY=
+
+LANGSMITH_PROJECT=
+LANGCHAIN_PROJECT=
+
+LANGSMITH_URL=

Dockerfile

@@ -0,0 +1,50 @@
+# ========================
+# Stage 1 - Builder
+# ========================
+FROM python:3.10-slim AS builder
+
+# Install build dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy only requirements first (better caching)
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# ========================
+# Stage 2 - Final Runtime Image
+# ========================
+FROM python:3.10-slim
+
+# Install minimal runtime dependencies
+RUN apt-get update && apt-get install -y \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user
+RUN useradd --create-home --shell /bin/bash appuser
+WORKDIR /app
+
+# Copy installed packages and application code
+COPY --from=builder /usr/local/lib/python3.10/site-packages /usr/local/lib/python3.10/site-packages
+COPY --from=builder /usr/local/bin /usr/local/bin
+COPY . /app
+
+# Set permissions
+RUN chown -R appuser:appuser /app
+USER appuser
+
+# Expose port
+EXPOSE 8000
+
+# Set the working directory to the backend folder
+WORKDIR /app
+
+# Command to run the FastAPI app
+CMD ["sh", "-c", "uvicorn api.app:app --host 0.0.0.0 --port ${PORT:-8000}"]

api/app.py

@@ -0,0 +1,105 @@
+
+import logging
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, HTTPException
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+# Import routers
+from api.routers import medical, health
+from api.middleware import (
+    ProcessTimeMiddleware, 
+    LoggingMiddleware, 
+    RateLimitMiddleware,
+    get_cors_middleware_config
+)
+from fastapi.middleware.cors import CORSMiddleware
+from api.exceptions import (
+    http_exception_handler,
+    validation_exception_handler,
+    general_exception_handler,
+    starlette_exception_handler
+)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan management with background initialization"""
+    # Startup
+    logger.info("Starting Medical RAG AI Advisor API...")
+    
+    # Start background initialization of heavy components
+    try:
+        from background_init import start_background_initialization
+        logger.info("🚀 Starting background initialization of components...")
+        start_background_initialization()
+        logger.info("API started successfully (components loading in background)")
+    except Exception as e:
+        logger.error(f"Failed to start background initialization: {e}")
+        logger.info("API started with lazy loading fallback")
+    
+    yield
+    
+    # Shutdown
+    logger.info("Shutting down Medical RAG AI Advisor API...")
+
+
+# Create FastAPI application
+app = FastAPI(
+    title="Medical RAG AI Advisor API",
+    description="Professional API for medical information retrieval and advisory services",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    lifespan=lifespan
+)
+
+# Add middleware
+app.add_middleware(CORSMiddleware, **get_cors_middleware_config())
+app.add_middleware(ProcessTimeMiddleware)
+app.add_middleware(LoggingMiddleware)
+app.add_middleware(RateLimitMiddleware, calls_per_minute=100)  # Adjust as needed
+
+# Add exception handlers
+app.add_exception_handler(HTTPException, http_exception_handler)
+app.add_exception_handler(RequestValidationError, validation_exception_handler)
+app.add_exception_handler(StarletteHTTPException, starlette_exception_handler)
+app.add_exception_handler(Exception, general_exception_handler)
+
+# Include routers
+app.include_router(health.router)
+app.include_router(medical.router)
+
+# Root endpoint
+@app.get("/")
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "name": "Medical RAG AI Advisor API",
+        "version": "1.0.0",
+        "description": "Professional API for medical information retrieval and advisory services",
+        "docs": "/docs",
+        "health": "/health",
+        "endpoints": {
+            "ask": "/ask",
+            "ask_stream": "/ask/stream",
+            "initialization_status": "/health/initialization"
+        }
+    }
+
+
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "api.app:app",
+        host="127.0.0.1",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )

api/exceptions.py

@@ -0,0 +1,71 @@
+"""
+Exception handlers for Medical RAG AI Advisor API
+"""
+import logging
+from datetime import datetime
+from fastapi import Request, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+from api.models import ErrorResponse
+
+logger = logging.getLogger(__name__)
+
+
+async def http_exception_handler(request: Request, exc: HTTPException):
+    """Handle HTTP exceptions"""
+    logger.error(f"HTTP Exception: {exc.status_code} - {exc.detail}")
+    
+    return JSONResponse(
+        status_code=exc.status_code,
+        content=ErrorResponse(
+            error="HTTP_ERROR",
+            message=exc.detail,
+            timestamp=datetime.now().isoformat()
+        ).dict()
+    )
+
+
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    """Handle request validation errors"""
+    logger.error(f"Validation Error: {exc.errors()}")
+    
+    return JSONResponse(
+        status_code=422,
+        content=ErrorResponse(
+            error="VALIDATION_ERROR",
+            message="Request validation failed",
+            details={"validation_errors": exc.errors()},
+            timestamp=datetime.now().isoformat()
+        ).dict()
+    )
+
+
+async def general_exception_handler(request: Request, exc: Exception):
+    """Handle general exceptions"""
+    logger.error(f"Unhandled Exception: {type(exc).__name__} - {str(exc)}")
+    
+    return JSONResponse(
+        status_code=500,
+        content=ErrorResponse(
+            error="INTERNAL_SERVER_ERROR",
+            message="An internal server error occurred",
+            details={"exception_type": type(exc).__name__},
+            timestamp=datetime.now().isoformat()
+        ).dict()
+    )
+
+
+async def starlette_exception_handler(request: Request, exc: StarletteHTTPException):
+    """Handle Starlette HTTP exceptions"""
+    logger.error(f"Starlette HTTP Exception: {exc.status_code} - {exc.detail}")
+    
+    return JSONResponse(
+        status_code=exc.status_code,
+        content=ErrorResponse(
+            error="HTTP_ERROR",
+            message=exc.detail,
+            timestamp=datetime.now().isoformat()
+        ).dict()
+    )

api/middleware.py

@@ -0,0 +1,100 @@
+"""
+Middleware for Medical RAG AI Advisor API
+"""
+import time
+import logging
+from typing import Callable, Awaitable
+from fastapi import Request, Response, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from starlette.middleware.base import BaseHTTPMiddleware
+
+logger = logging.getLogger(__name__)
+
+
+class ProcessTimeMiddleware(BaseHTTPMiddleware):
+    """Middleware to add processing time to response headers"""
+    
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        start_time = time.time()
+        response = await call_next(request)
+        process_time = time.time() - start_time
+        response.headers["X-Process-Time"] = f"{process_time:.4f}"
+        return response
+
+
+class LoggingMiddleware(BaseHTTPMiddleware):
+    """Middleware for request/response logging"""
+    
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        start_time = time.time()
+        
+        # Log request
+        logger.info(f"Request: {request.method} {request.url}")
+        
+        try:
+            response = await call_next(request)
+            process_time = time.time() - start_time
+            
+            # Log response
+            logger.info(
+                f"Response: {response.status_code} - "
+                f"Time: {process_time:.4f}s - "
+                f"Path: {request.url.path}"
+            )
+            
+            return response
+            
+        except Exception as e:
+            process_time = time.time() - start_time
+            logger.error(
+                f"Error: {str(e)} - "
+                f"Time: {process_time:.4f}s - "
+                f"Path: {request.url.path}"
+            )
+            raise
+
+
+class RateLimitMiddleware(BaseHTTPMiddleware):
+    """Simple rate limiting middleware"""
+    
+    def __init__(self, app, calls_per_minute: int = 60):
+        super().__init__(app)
+        self.calls_per_minute = calls_per_minute
+        self.client_calls = {}
+    
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        client_ip = request.client.host
+        current_time = time.time()
+        
+        # Clean old entries
+        self.client_calls = {
+            ip: calls for ip, calls in self.client_calls.items()
+            if any(call_time > current_time - 60 for call_time in calls)
+        }
+        
+        # Check rate limit
+        if client_ip in self.client_calls:
+            recent_calls = [
+                call_time for call_time in self.client_calls[client_ip]
+                if call_time > current_time - 60
+            ]
+            if len(recent_calls) >= self.calls_per_minute:
+                raise HTTPException(
+                    status_code=429,
+                    detail="Rate limit exceeded. Please try again later."
+                )
+            self.client_calls[client_ip] = recent_calls + [current_time]
+        else:
+            self.client_calls[client_ip] = [current_time]
+        
+        return await call_next(request)
+
+
+def get_cors_middleware_config():
+    """Get CORS middleware configuration"""
+    return {
+        "allow_origins": ["*"],  # Configure appropriately for production
+        "allow_credentials": True,
+        "allow_methods": ["*"],
+        "allow_headers": ["*"],
+    }

api/models.py

@@ -0,0 +1,97 @@
+"""
+API Models and Schemas for Medical RAG AI Advisor
+"""
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+from enum import Enum
+
+
+class QueryType(str, Enum):
+    """Types of medical queries supported"""
+    GENERAL = "general"
+    DRUG_INTERACTION = "drug_interaction"
+    SIDE_EFFECTS = "side_effects"
+    GUIDELINES = "guidelines"
+    COMPARISON = "comparison"
+
+
+class QueryRequest(BaseModel):
+    """Request model for medical queries"""
+    query: str = Field(..., description="Medical question or query", min_length=1)
+    query_type: Optional[QueryType] = Field(None, description="Type of medical query")
+    context: Optional[str] = Field(None, description="Additional context for the query")
+    patient_info: Optional[Dict[str, Any]] = Field(None, description="Patient information if relevant")
+
+
+class QueryResponse(BaseModel):
+    """Response model for medical queries"""
+    response: str = Field(..., description="AI-generated medical response")
+    sources: Optional[List[str]] = Field(None, description="Sources used for the response")
+    confidence: Optional[float] = Field(None, description="Confidence score of the response")
+    query_type: Optional[QueryType] = Field(None, description="Detected or specified query type")
+    processing_time: Optional[float] = Field(None, description="Time taken to process the query")
+
+
+class StreamChunk(BaseModel):
+    """Model for streaming response chunks"""
+    chunk: str = Field(..., description="Chunk of the streaming response")
+    is_final: bool = Field(False, description="Whether this is the final chunk")
+
+
+class SideEffectReport(BaseModel):
+    """Model for side effect reporting"""
+    drug_name: str = Field(..., description="Name of the drug")
+    side_effects: str = Field(..., description="Reported side effects")
+    patient_age: Optional[int] = Field(None, description="Patient age")
+    patient_gender: Optional[str] = Field(None, description="Patient gender")
+    dosage: Optional[str] = Field(None, description="Drug dosage")
+    duration: Optional[str] = Field(None, description="Duration of treatment")
+    severity: Optional[str] = Field(None, description="Severity of side effects")
+    outcome: Optional[str] = Field(None, description="Outcome of the side effects")
+    additional_details: Optional[str] = Field(None, description="Additional clinical details")
+
+
+class SideEffectResponse(BaseModel):
+    """Response model for side effect reporting"""
+    report_id: str = Field(..., description="Unique identifier for the report")
+    status: str = Field(..., description="Status of the report submission")
+    message: str = Field(..., description="Confirmation message")
+    recommendations: Optional[List[str]] = Field(None, description="Clinical recommendations")
+
+
+class ComparisonRequest(BaseModel):
+    """Request model for provider/treatment comparisons"""
+    providers: List[str] = Field(..., description="List of providers to compare", min_items=2)
+    criteria: Optional[List[str]] = Field(None, description="Specific criteria for comparison")
+
+
+class ComparisonResponse(BaseModel):
+    """Response model for provider/treatment comparisons"""
+    comparison: str = Field(..., description="Detailed comparison analysis")
+    summary: Dict[str, Any] = Field(..., description="Summary of key differences")
+    recommendations: Optional[str] = Field(None, description="Recommendations based on comparison")
+
+
+class InitializationStatus(BaseModel):
+    """Initialization status response model"""
+    is_complete: bool = Field(..., description="Whether initialization is complete")
+    status_message: str = Field(..., description="Current initialization status")
+    is_successful: bool = Field(..., description="Whether initialization was successful")
+    error: Optional[str] = Field(None, description="Initialization error if any")
+
+
+class HealthStatus(BaseModel):
+    """Health check response model"""
+    status: str = Field(..., description="API health status")
+    version: str = Field(..., description="API version")
+    timestamp: str = Field(..., description="Current timestamp")
+    components: Dict[str, str] = Field(..., description="Status of system components")
+    initialization: Optional[InitializationStatus] = Field(None, description="Background initialization status")
+
+
+class ErrorResponse(BaseModel):
+    """Error response model"""
+    error: str = Field(..., description="Error type")
+    message: str = Field(..., description="Error message")
+    details: Optional[Dict[str, Any]] = Field(None, description="Additional error details")
+    timestamp: str = Field(..., description="Error timestamp")

api/routers/health.py

@@ -0,0 +1,136 @@
+"""
+Health Check and System Status Router
+"""
+from datetime import datetime
+from fastapi import APIRouter
+import sys
+import os
+
+# Add src to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+from api.models import HealthStatus, InitializationStatus
+
+router = APIRouter(prefix="/health", tags=["health"])
+
+
+@router.get("/", response_model=HealthStatus)
+async def health_check():
+    """
+    Check the health status of the API and its components
+    """
+    components = {}
+    
+    # Check agent availability
+    try:
+        from agent import safe_run_agent
+        components["agent"] = "healthy"
+    except Exception:
+        components["agent"] = "unhealthy"
+    
+    # Check vector store
+    try:
+        from vector_store import VectorStore
+        components["vector_store"] = "healthy"
+    except Exception:
+        components["vector_store"] = "unhealthy"
+    
+    # Check data loaders
+    try:
+        from data_loaders import load_pdf_documents
+        components["data_loaders"] = "healthy"
+    except Exception:
+        components["data_loaders"] = "unhealthy"
+    
+    # Check tools
+    try:
+        from tools import medical_guidelines_knowledge_tool
+        components["tools"] = "healthy"
+    except Exception:
+        components["tools"] = "unhealthy"
+    
+    # Check initialization status
+    initialization_status = None
+    try:
+        from background_init import (
+            is_initialization_complete, 
+            get_initialization_status, 
+            is_initialization_successful,
+            get_initialization_error
+        )
+        
+        initialization_status = InitializationStatus(
+            is_complete=is_initialization_complete(),
+            status_message=get_initialization_status(),
+            is_successful=is_initialization_successful(),
+            error=str(get_initialization_error()) if get_initialization_error() else None
+        )
+    except Exception as e:
+        initialization_status = InitializationStatus(
+            is_complete=False,
+            status_message=f"Unable to check initialization status: {str(e)}",
+            is_successful=False,
+            error=str(e)
+        )
+    
+    # Overall status
+    overall_status = "healthy" if all(
+        status == "healthy" for status in components.values()
+    ) else "degraded"
+    
+    return HealthStatus(
+        status=overall_status,
+        version="1.0.0",
+        timestamp=datetime.now().isoformat(),
+        components=components,
+        initialization=initialization_status
+    )
+
+
+@router.get("/ping")
+async def ping():
+    """
+    Simple ping endpoint for basic connectivity check
+    """
+    return {"message": "pong", "timestamp": datetime.now().isoformat()}
+
+
+@router.get("/initialization", response_model=InitializationStatus)
+async def get_initialization_status():
+    """
+    Get the current initialization status of background components
+    """
+    try:
+        from background_init import (
+            is_initialization_complete, 
+            get_initialization_status, 
+            is_initialization_successful,
+            get_initialization_error
+        )
+        
+        return InitializationStatus(
+            is_complete=is_initialization_complete(),
+            status_message=get_initialization_status(),
+            is_successful=is_initialization_successful(),
+            error=str(get_initialization_error()) if get_initialization_error() else None
+        )
+    except Exception as e:
+        return InitializationStatus(
+            is_complete=False,
+            status_message=f"Unable to check initialization status: {str(e)}",
+            is_successful=False,
+            error=str(e)
+        )
+
+
+@router.get("/version")
+async def get_version():
+    """
+    Get API version information
+    """
+    return {
+        "version": "1.0.0",
+        "name": "Medical RAG AI Advisor API",
+        "description": "Professional API for medical information retrieval and advisory services",
+        "build_date": "2024-01-01"
+    }

api/routers/medical.py

@@ -0,0 +1,58 @@
+"""
+Medical Query Router for RAG AI Advisor
+"""
+import asyncio
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+import sys
+import os
+
+# Add src to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+from core.agent import safe_run_agent, safe_run_agent_streaming
+
+router = APIRouter(tags=["medical"])
+
+
+@router.get("/ask")
+async def ask(query: str):
+    """
+    Process a medical query - agent decides which tools to use
+    """
+    try:
+        response = await safe_run_agent(user_input=query)
+        return {"response": response}
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing medical query: {str(e)}"
+        )
+
+
+@router.get("/ask/stream")
+async def ask_stream(query: str):
+    """
+    Process a medical query with streaming response - agent decides which tools to use
+    """
+    async def event_stream():
+        try:
+            chunk_buffer = ""
+            async for chunk in safe_run_agent_streaming(user_input=query):
+                chunk_buffer += chunk
+                
+                # Send chunks in reasonable sizes for smoother streaming
+                if len(chunk_buffer) >= 10:  # Adjust this value as needed
+                    yield chunk_buffer
+                    chunk_buffer = ""
+                    await asyncio.sleep(0.01)  # Small delay for smoother streaming
+            
+            # Send any remaining content
+            if chunk_buffer:
+                yield chunk_buffer
+                
+        except Exception as e:
+            yield f"Error: {str(e)}"
+    
+    return StreamingResponse(event_stream(), media_type="text/markdown")

api/routers/side_effects.py

@@ -0,0 +1,165 @@
+"""
+Side Effects Reporting Router
+"""
+import uuid
+import time
+from datetime import datetime
+from fastapi import APIRouter, HTTPException
+import sys
+import os
+
+# Add backend and src directories to path for imports
+backend_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+src_path = os.path.join(backend_path, 'src')
+sys.path.append(backend_path)
+sys.path.append(src_path)
+
+from api.models import SideEffectReport
+from tools import side_effect_recording_tool
+from github_storage import get_github_storage
+
+router = APIRouter(prefix="/side-effects", tags=["side-effects"])
+
+
+@router.post("/report")
+async def report_side_effect(report: SideEffectReport):
+    """
+    Submit a side effect report for pharmacovigilance
+    """
+    try:
+        # Prepare the report text for the side effect tool
+        report_text = f"Drug: {report.drug_name}, Side effects: {report.side_effects}"
+        
+        if report.patient_age:
+            report_text += f", Patient age: {report.patient_age}"
+        if report.patient_gender:
+            report_text += f", Patient gender: {report.patient_gender}"
+        if report.dosage:
+            report_text += f", Dosage: {report.dosage}"
+        if report.duration:
+            report_text += f", Duration: {report.duration}"
+        if report.severity:
+            report_text += f", Severity: {report.severity}"
+        if report.outcome:
+            report_text += f", Outcome: {report.outcome}"
+        if report.additional_details:
+            report_text += f", Additional details: {report.additional_details}"
+        
+        # Process through the existing side effect recording tool
+        result = side_effect_recording_tool(report_text)
+        
+        return {"result": result}
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error processing side effect report: {str(e)}"
+        )
+
+
+@router.get("/reports/summary")
+async def get_reports_summary():
+    """
+    Get summary of side effect reports from GitHub repository
+    """
+    try:
+        import pandas as pd
+        import os
+        
+        # Try to get reports from GitHub first
+        github_storage = get_github_storage()
+        reports = github_storage.get_side_effects_reports()
+        
+        if not reports:
+            # Fallback to local file if GitHub fails
+            csv_path = "side_effects_reports.csv"
+            
+            if not os.path.exists(csv_path):
+                return {
+                    "total_reports": 0,
+                    "message": "No side effect reports found"
+                }
+            
+            df = pd.read_csv(csv_path)
+        else:
+            # Convert GitHub reports to DataFrame
+            df = pd.DataFrame(reports)
+        
+        if df.empty:
+            return {
+                "total_reports": 0,
+                "message": "No side effect reports found"
+            }
+        
+        summary = {
+            "total_reports": len(df),
+            "unique_drugs": df['drug_name'].nunique() if 'drug_name' in df.columns else 0,
+            "recent_reports": len(df[df['timestamp'] >= (datetime.now() - pd.Timedelta(days=30)).strftime('%Y-%m-%d')]) if 'timestamp' in df.columns else 0,
+            "most_reported_drugs": df['drug_name'].value_counts().head(5).to_dict() if 'drug_name' in df.columns else {}
+        }
+        
+        return summary
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error retrieving reports summary: {str(e)}"
+        )
+
+
+@router.get("/drug/{drug_name}/reports")
+async def get_drug_reports(drug_name: str):
+    """
+    Get side effect reports for a specific drug from GitHub repository
+    """
+    try:
+        # Try to get reports from GitHub first
+        github_storage = get_github_storage()
+        reports = github_storage.get_drug_reports(drug_name)
+        
+        if reports:
+            return {
+                "drug_name": drug_name,
+                "total_reports": len(reports),
+                "reports": reports
+            }
+        
+        # Fallback to local file if GitHub fails or no reports found
+        import pandas as pd
+        import os
+        
+        csv_path = "side_effects_reports.csv"
+        
+        if not os.path.exists(csv_path):
+            return {
+                "drug_name": drug_name,
+                "reports": [],
+                "message": "No reports found"
+            }
+        
+        df = pd.read_csv(csv_path)
+        
+        # Filter reports for the specific drug (case-insensitive)
+        drug_reports = df[df['drug_name'].str.lower() == drug_name.lower()]
+        
+        if drug_reports.empty:
+            return {
+                "drug_name": drug_name,
+                "reports": [],
+                "message": f"No reports found for {drug_name}"
+            }
+        
+        # Convert to list of dictionaries
+        local_reports = drug_reports.to_dict('records')
+        
+        return {
+            "drug_name": drug_name,
+            "total_reports": len(local_reports),
+            "reports": local_reports
+        }
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error retrieving drug reports: {str(e)}"
+        )