Fix: Update response format and add better error handling

requirements.txt

@@ -1,7 +1,6 @@
 fastapi==0.104.1
-uvicorn==0.24.0
-python-dotenv==1.0.0
-groq>=0.9.0,<0.12.0
-httpx==0.24.1
+uvicorn[standard]==0.24.0
 pydantic==2.5.0
+pydantic-settings==2.1.0
+groq==0.4.0
 python-multipart==0.0.6

src/api/routes.py

@@ -1,114 +1,104 @@
+import logging
 from fastapi import APIRouter, HTTPException, UploadFile, File
 from models.request_models import ProviderNotesRequest, FileUploadResponse
 from models.response_models import CodingResponse
 from services.groq_service import groq_service
 from services.file_service import file_service
-import logging
 
 router = APIRouter()
 logger = logging.getLogger(__name__)
 
 
-# EXISTING ENDPOINT - DO NOT CHANGE
 @router.post("/coding", response_model=CodingResponse)
 async def analyze_provider_notes(request: ProviderNotesRequest):
     """
     Analyze provider notes and extract ICD-10 and CPT codes
     
-    This endpoint accepts provider notes as text input.
+    This endpoint accepts provider notes as text input and returns:
+    - ICD-10 diagnostic codes with explanations
+    - CPT procedure codes with explanations
+    - Overall encounter summary
     """
     try:
-        logger.info("Received coding request")
-        
-        provider_notes = request.provider_notes
+        logger.info(f"📥 Received coding request (notes length: {len(request.provider_notes)})")
         
-        if not provider_notes or len(provider_notes.strip()) < 10:
+        # Validate input
+        if not request.provider_notes or len(request.provider_notes.strip()) < 10:
             raise HTTPException(
                 status_code=400,
                 detail="Provider notes must be at least 10 characters long"
             )
         
-        result = await groq_service.analyze_provider_notes(provider_notes)
+        # Analyze with Groq
+        result = groq_service.analyze_provider_notes(request.provider_notes)
         
-        logger.info("Successfully processed coding request")
+        logger.info(f"✅ Analysis complete: {len(result.get('icd_codes', []))} ICD codes, {len(result.get('cpt_codes', []))} CPT codes")
         
-        return CodingResponse(
-            cpt_codes=result.get("CPT", []),
-            cpt_explanation=result.get("CPT_explanation", ""),
-            icd_codes=result.get("ICD", []),
-            icd_explanation=result.get("ICD_explanation", "")
-        )
+        return result
         
     except HTTPException:
         raise
+    except ValueError as e:
+        logger.error(f"❌ Validation error: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))
     except Exception as e:
-        logger.error(f"Error in analyze_provider_notes: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Error processing request: {str(e)}"
-        )
+        logger.error(f"❌ Error processing request: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error processing request: {str(e)}")
 
 
-# FILE UPLOAD ENDPOINT WITH REGEX-BASED PII REMOVAL
 @router.post("/upload-file", response_model=FileUploadResponse)
 async def upload_provider_notes_file(file: UploadFile = File(...)):
     """
-    Upload a TXT file containing provider notes and extract ICD-10 and CPT codes
+    Upload a provider notes file (.txt), remove PII, and analyze
     
-    This endpoint:
-    1. Extracts text from uploaded TXT file
-    2. Automatically detects and removes patient personal information using regex patterns
-    3. Processes sanitized text through LLM
-    4. Returns ICD-10 and CPT codes
-    
-    Args:
-        file: TXT file containing provider notes
-        
     Returns:
-        FileUploadResponse with codes, explanations, and PII removal info
+    - File processing info (PII removal stats)
+    - ICD-10 codes with explanations
+    - CPT codes with explanations
+    - Overall summary
     """
     try:
-        logger.info(f"Received file upload request: {file.filename}")
+        logger.info(f"📤 Received file upload: {file.filename}")
+        
+        # Validate file type
+        if not file.filename.endswith('.txt'):
+            raise HTTPException(
+                status_code=400,
+                detail="Only .txt files are allowed"
+            )
+        
+        # Read file content
+        content = await file.read()
+        text = content.decode('utf-8')
         
-        # Step 1: Extract text from file with automatic regex-based PII removal
-        extraction_result = await file_service.extract_text_from_file(
-            file=file,
-            remove_pii=True  # Always remove PII using regex patterns
-        )
+        logger.info(f"📄 File read successfully (length: {len(text)})")
         
-        extracted_text = extraction_result["text"]
-        filename = extraction_result["filename"]
-        text_length = extraction_result["text_length"]
-        pii_info = extraction_result["pii_info"]
+        # Remove PII
+        cleaned_text, pii_count = file_service.remove_pii(text)
         
-        logger.info(f"Extracted {text_length} characters from {filename}")
+        logger.info(f"🔒 PII removal complete: {pii_count} entities removed")
         
-        if pii_info["pii_removed"]:
-            logger.info(f"Removed {pii_info['pii_count']} PII entities using regex before processing")
+        # Analyze with Groq
+        result = groq_service.analyze_provider_notes(cleaned_text)
         
-        # Step 2: Process sanitized text through Groq LLM
-        coding_result = await groq_service.analyze_provider_notes(extracted_text)
+        # Combine results
+        response = {
+            "success": True,
+            "filename": file.filename,
+            "extracted_text_length": len(text),
+            "pii_removed": pii_count > 0,
+            "pii_count": pii_count,
+            "icd_codes": result.get("icd_codes", []),
+            "cpt_codes": result.get("cpt_codes", []),
+            "overall_summary": result.get("overall_summary", "")
+        }
         
-        logger.info(f"Successfully processed file: {filename}")
+        logger.info(f"✅ File processing complete")
         
-        # Step 3: Return combined response with PII info
-        return FileUploadResponse(
-            success=True,
-            filename=filename,
-            extracted_text_length=text_length,
-            pii_removed=pii_info["pii_removed"],
-            pii_count=pii_info["pii_count"],
-            cpt_codes=coding_result.get("CPT", []),
-            cpt_explanation=coding_result.get("CPT_explanation", ""),
-            icd_codes=coding_result.get("ICD", []),
-            icd_explanation=coding_result.get("ICD_explanation", "")
-        )
+        return response
         
     except HTTPException:
         raise
     except Exception as e:
-        logger.error(f"Error in upload_provider_notes_file: {str(e)}")
-        raise HTTPException(
-            status_code=500,
-            detail=f"Error processing uploaded file: {str(e)}"
-        )
+        logger.error(f"❌ Error processing uploaded file: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error processing uploaded file: {str(e)}")

src/config/settings.py

@@ -1,23 +1,26 @@
 import os
-from dotenv import load_dotenv
+from pydantic_settings import BaseSettings
 
-# Load environment variables from .env file
-load_dotenv()
+class Settings(BaseSettings):
+    # Groq API Configuration
+    groq_api_key: str = os.getenv("GROQ_API_KEY", "")
+    groq_model: str = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")
+    
+    # API Configuration
+    api_title: str = "ICD-CPT Coding API"
+    api_version: str = "1.0.0"
+    api_description: str = "Medical coding assistant powered by Groq LLaMA 3.3 70B"
+    
+    class Config:
+        env_file = ".env"
+        case_sensitive = False
 
-class Settings:
-    def __init__(self):
-        self.GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-        self.MODEL_ID = os.getenv("MODEL_ID", "llama-3.3-70b-versatile")
-        
-        # Validate required environment variables
-        if not self.GROQ_API_KEY:
-            raise ValueError(
-                "GROQ_API_KEY not found in environment variables. "
-                "Please set it in Hugging Face Space Settings -> Repository secrets"
-            )
-        
-        print(f"Settings loaded successfully")
-        print(f"Model ID: {self.MODEL_ID}")
-        print(f"API Key configured: {self.GROQ_API_KEY[:10]}...")
+settings = Settings()
 
-settings = Settings()
+# Validate API key on startup
+if not settings.groq_api_key:
+    print("⚠️ WARNING: GROQ_API_KEY is not set! API will not function properly.")
+    print("Please set GROQ_API_KEY in Hugging Face Space secrets.")
+else:
+    print(f"✅ Groq API Key loaded (length: {len(settings.groq_api_key)})")
+    print(f"✅ Using model: {settings.groq_model}")

src/main.py

@@ -1,20 +1,25 @@
+import logging
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from api.routes import router
-import uvicorn
-import logging
+from config.settings import settings
 
 # Configure logging
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
 logger = logging.getLogger(__name__)
 
+# Create FastAPI app
 app = FastAPI(
-    title="ICD-10 & CPT Code Analyzer",
-    description="AI-powered medical coding assistant",
-    version="1.1.0"
+    title=settings.api_title,
+    version=settings.api_version,
+    description=settings.api_description
 )
 
-# CORS middleware
+# CORS configuration
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -23,24 +28,49 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Include API routes
+# Include routes
 app.include_router(router, prefix="/api")
 
+@app.on_event("startup")
+async def startup_event():
+    """Log startup information"""
+    logger.info("=" * 50)
+    logger.info(f"🚀 {settings.api_title} v{settings.api_version}")
+    logger.info("=" * 50)
+    
+    if settings.groq_api_key:
+        logger.info(f"✅ Groq API Key: Configured (length: {len(settings.groq_api_key)})")
+        logger.info(f"✅ Groq Model: {settings.groq_model}")
+    else:
+        logger.error("❌ GROQ_API_KEY is NOT set!")
+        logger.error("⚠️ API will NOT function without valid API key")
+    
+    logger.info("=" * 50)
+
 @app.get("/")
 async def root():
+    """Root endpoint"""
     return {
-        "message": "ICD-10 & CPT Code Analyzer API",
-        "version": "1.1.0",
+        "service": settings.api_title,
+        "version": settings.api_version,
+        "status": "running",
         "endpoints": {
-            "text_input": "/api/coding",
-            "file_upload": "/api/upload-file",
-            "docs": "/docs"
+            "docs": "/docs",
+            "health": "/api/v1/health",
+            "coding": "/api/coding",
+            "upload": "/api/upload-file"
         }
     }
 
-@app.get("/health")
+@app.get("/api/v1/health")
 async def health_check():
-    return {"status": "healthy"}
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    """Health check endpoint"""
+    api_key_status = "configured" if settings.groq_api_key else "missing"
+    
+    return {
+        "status": "healthy",
+        "service": settings.api_title,
+        "version": settings.api_version,
+        "groq_api_key": api_key_status,
+        "groq_model": settings.groq_model
+    }

src/models/response_models.py

@@ -1,6 +1,16 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from typing import List, Optional
 
+class ICDCode(BaseModel):
+    code: str
+    description: str
+    explanation: str
+
+class CPTCode(BaseModel):
+    code: str
+    description: str
+    explanation: str
+
 class ProviderNotesRequest(BaseModel):
     provider_notes: str = Field(
         ..., 
@@ -20,33 +30,40 @@ class ProviderNote(BaseModel):
     note: str
 
 class CodingResponse(BaseModel):
-    cpt_codes: list
-    cpt_explanation: str
-    icd_codes: list
-    icd_explanation: str
-
-
-# PII Detection Detail Model
-class PIIDetail(BaseModel):
-    """Details of detected PII entity"""
-    entity_type: str = Field(description="Type of PII detected (e.g., PERSON, PHONE_NUMBER)")
-    start: int = Field(description="Start position in original text")
-    end: int = Field(description="End position in original text")
-    score: float = Field(description="Confidence score")
+    icd_codes: List[ICDCode]
+    cpt_codes: List[CPTCode]
+    overall_summary: str
 
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "icd_codes": [
+                    {
+                        "code": "J20.9",
+                        "description": "Acute bronchitis, unspecified",
+                        "explanation": "Patient presents with acute bronchitis as documented in provider notes"
+                    }
+                ],
+                "cpt_codes": [
+                    {
+                        "code": "99213",
+                        "description": "Office visit, established patient",
+                        "explanation": "Comprehensive examination performed as documented"
+                    }
+                ],
+                "overall_summary": "Patient encounter for acute bronchitis with examination and treatment"
+            }
+        }
 
-# Updated File Upload Response with PII info
 class FileUploadResponse(BaseModel):
-    """Response model for file upload endpoint with PII removal info"""
-    success: bool = Field(description="Whether file processing was successful")
-    filename: str = Field(description="Name of uploaded file")
-    extracted_text_length: int = Field(description="Length of extracted text (after PII removal)")
-    pii_removed: bool = Field(description="Whether PII was detected and removed")
-    pii_count: int = Field(description="Number of PII entities removed")
-    cpt_codes: list = Field(description="List of CPT codes")
-    cpt_explanation: str = Field(description="Explanation of CPT codes")
-    icd_codes: list = Field(description="List of ICD codes")
-    icd_explanation: str = Field(description="Explanation of ICD codes")
+    success: bool
+    filename: str
+    extracted_text_length: int
+    pii_removed: bool
+    pii_count: int
+    icd_codes: List[ICDCode]
+    cpt_codes: List[CPTCode]
+    overall_summary: str
     
     class Config:
         json_schema_extra = {

src/services/groq_service.py

@@ -1,61 +1,127 @@
-from groq import Groq
 import json
-import sys
-import os
-
-# Add parent directory to path for imports
-sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
+import logging
+from groq import Groq
 from config.settings import settings
-from utils.prompts import SYSTEM_PROMPT, create_user_prompt
+from utils.prompts import get_coding_prompt
+
+logger = logging.getLogger(__name__)
 
 class GroqService:
     def __init__(self):
+        """Initialize Groq client with API key from settings"""
+        if not settings.groq_api_key:
+            logger.error("❌ GROQ_API_KEY is not set!")
+            raise ValueError("GROQ_API_KEY environment variable is required")
+        
         try:
-            print(f"🔧 Initializing Groq client...")
-            self.client = Groq(api_key=settings.GROQ_API_KEY)
-            self.model_id = settings.MODEL_ID
-            print(f"Groq client initialized successfully with model: {self.model_id}")
+            self.client = Groq(api_key=settings.groq_api_key)
+            self.model = settings.groq_model
+            logger.info(f"✅ Groq client initialized with model: {self.model}")
         except Exception as e:
-            print(f"Failed to initialize Groq client: {str(e)}")
+            logger.error(f"❌ Failed to initialize Groq client: {str(e)}")
             raise
     
-    async def analyze_provider_notes(self, provider_notes: str) -> dict:
+    def analyze_provider_notes(self, provider_notes: str) -> dict:
         """
-        Analyze provider notes and return ICD and CPT codes with explanations
+        Analyze provider notes and extract ICD-10 and CPT codes
+        
+        Args:
+            provider_notes: Clinical provider notes text
+            
+        Returns:
+            dict: Parsed coding response with ICD-10, CPT codes and summary
         """
         try:
-            print(f"Analyzing provider notes...")
-            # Create the chat completion with system and user prompts
-            chat_completion = self.client.chat.completions.create(
+            logger.info(f"📝 Analyzing provider notes (length: {len(provider_notes)})")
+            
+            # Get the prompt
+            prompt = get_coding_prompt(provider_notes)
+            
+            # Call Groq API
+            logger.info(f"🚀 Calling Groq API with model: {self.model}")
+            response = self.client.chat.completions.create(
+                model=self.model,
                 messages=[
                     {
                         "role": "system",
-                        "content": SYSTEM_PROMPT
+                        "content": "You are a medical coding expert specializing in ICD-10 and CPT coding. Always respond with valid JSON."
                     },
                     {
                         "role": "user",
-                        "content": create_user_prompt(provider_notes)
+                        "content": prompt
                     }
                 ],
-                model=self.model_id,
-                temperature=0.1,  # Low temperature for consistent, factual outputs
-                response_format={"type": "json_object"}  # Force JSON response
+                temperature=0.3,
+                max_tokens=2000,
+                response_format={"type": "json_object"}
             )
             
-            # Extract and parse the response
-            response_content = chat_completion.choices[0].message.content
-            print(f"Received response from Groq API")
-            parsed_response = json.loads(response_content)
+            # Extract response
+            raw_response = response.choices[0].message.content
+            logger.info(f"📥 Received response from Groq (length: {len(raw_response)})")
+            logger.debug(f"Raw response: {raw_response[:500]}...")
             
-            return parsed_response
+            # Parse JSON
+            parsed_response = json.loads(raw_response)
+            
+            # Validate and structure response
+            result = self._structure_response(parsed_response)
+            
+            logger.info(f"✅ Successfully analyzed notes: {len(result.get('icd_codes', []))} ICD codes, {len(result.get('cpt_codes', []))} CPT codes")
+            
+            return result
             
         except json.JSONDecodeError as e:
-            print(f"JSON parsing error: {str(e)}")
-            raise ValueError(f"Failed to parse JSON response from model: {str(e)}")
+            logger.error(f"❌ JSON parsing error: {str(e)}")
+            logger.error(f"Raw response: {raw_response}")
+            raise ValueError(f"Failed to parse Groq response as JSON: {str(e)}")
+        
         except Exception as e:
-            print(f"Groq API error: {str(e)}")
-            raise Exception(f"Error calling Groq API: {str(e)}")
+            logger.error(f"❌ Error analyzing provider notes: {str(e)}")
+            raise
+    
+    def _structure_response(self, parsed_response: dict) -> dict:
+        """
+        Structure and validate the response from Groq
+        
+        Args:
+            parsed_response: Raw parsed JSON from Groq
+            
+        Returns:
+            dict: Properly structured response
+        """
+        # Handle different possible response formats
+        icd_codes = []
+        cpt_codes = []
+        overall_summary = parsed_response.get("overall_summary", "")
+        
+        # Extract ICD codes
+        raw_icd = parsed_response.get("icd_codes", [])
+        if isinstance(raw_icd, list):
+            for icd in raw_icd:
+                if isinstance(icd, dict):
+                    icd_codes.append({
+                        "code": icd.get("code", ""),
+                        "description": icd.get("description", ""),
+                        "explanation": icd.get("explanation", "")
+                    })
+        
+        # Extract CPT codes
+        raw_cpt = parsed_response.get("cpt_codes", [])
+        if isinstance(raw_cpt, list):
+            for cpt in raw_cpt:
+                if isinstance(cpt, dict):
+                    cpt_codes.append({
+                        "code": cpt.get("code", ""),
+                        "description": cpt.get("description", ""),
+                        "explanation": cpt.get("explanation", "")
+                    })
+        
+        return {
+            "icd_codes": icd_codes,
+            "cpt_codes": cpt_codes,
+            "overall_summary": overall_summary
+        }
 
-# Don't initialize here - let it be initialized when imported
+# Global instance
 groq_service = GroqService()

src/utils/prompts.py

@@ -43,4 +43,52 @@ def create_user_prompt(provider_notes: str) -> str:
 PROVIDER NOTES:
 {provider_notes}
 
-Respond ONLY with the JSON object following the exact format specified in the system prompt."""
+Respond ONLY with the JSON object following the exact format specified in the system prompt."""
+
+def get_coding_prompt(provider_notes: str) -> str:
+    """
+    Generate prompt for medical coding analysis
+    
+    Args:
+        provider_notes: Clinical provider notes
+        
+    Returns:
+        str: Formatted prompt for Groq API
+    """
+    return f"""You are an expert medical coder. Analyze the following provider notes and extract:
+
+1. **ICD-10 Diagnostic Codes**: Identify all relevant diagnoses
+2. **CPT Procedure Codes**: Identify all billable procedures/services
+3. **Overall Summary**: Brief summary of the encounter
+
+**Provider Notes:**
+{provider_notes}
+
+**Instructions:**
+- Provide accurate ICD-10 and CPT codes based on current coding guidelines
+- Include detailed explanations for each code
+- Provide an overall summary of the patient encounter
+- Respond ONLY with valid JSON in this exact format:
+
+{{
+  "icd_codes": [
+    {{
+      "code": "J20.9",
+      "description": "Acute bronchitis, unspecified",
+      "explanation": "Patient presents with acute bronchitis as documented with cough and sputum production"
+    }}
+  ],
+  "cpt_codes": [
+    {{
+      "code": "99213",
+      "description": "Office or other outpatient visit for established patient, moderate complexity",
+      "explanation": "Established patient office visit with moderate medical decision making"
+    }}
+  ],
+  "overall_summary": "Patient encounter for acute respiratory infection with examination and prescription provided"
+}}
+
+**Important:** 
+- Return ONLY valid JSON, no markdown, no code blocks
+- Include at least one ICD-10 code and one CPT code if applicable
+- Be specific and accurate with coding"""