Initial commit: ICD-CPT Coding API

.gitattributes

@@ -0,0 +1,34 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Python files
+*.py text eol=lf
+*.pyi text eol=lf
+
+# Shell scripts
+*.sh text eol=lf
+
+# Docker files
+Dockerfile text eol=lf
+*.dockerfile text eol=lf
+
+# Config files
+*.yml text eol=lf
+*.yaml text eol=lf
+*.json text eol=lf
+*.toml text eol=lf
+*.ini text eol=lf
+*.cfg text eol=lf
+
+# Documentation
+*.md text eol=lf
+*.txt text eol=lf
+
+# Git
+.gitignore text eol=lf
+.gitattributes text eol=lf
+
+# Windows specific
+*.bat text eol=crlf
+*.cmd text eol=crlf
+*.ps1 text eol=crlf

.gitignore

@@ -0,0 +1,30 @@
+# Environment variables
+.env
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+build/
+dist/
+*.egg-info/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Test
+.pytest_cache/
+.coverage
+htmlcov/

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the entire project
+COPY . .
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "src/main.py"]

README.md

@@ -0,0 +1,104 @@
+# ICD-CPT Model
+
+This project implements a FastAPI application that utilizes the Groq API and a language model (Llama 3.3 70b Versatile) to provide CPT and ICD coding based on provider notes. The application is designed to return structured JSON responses that include the predicted codes along with explanations for each code.
+
+## Project Structure
+
+- **src/**: Contains the main application code.
+  - **main.py**: Entry point for the FastAPI application.
+  - **api/**: Contains API route definitions.
+    - **routes.py**: Defines the endpoints for the application.
+  - **services/**: Contains service logic for interacting with external APIs.
+    - **groq_service.py**: Handles requests to the Groq API and processes responses.
+  - **models/**: Contains data models for requests and responses.
+    - **request_models.py**: Defines request models for incoming data.
+    - **response_models.py**: Defines response models for outgoing data.
+  - **config/**: Contains configuration settings for the application.
+    - **settings.py**: Configuration for API keys and model IDs.
+  - **utils/**: Contains utility functions and prompt templates.
+    - **prompts.py**: Defines prompt templates for querying the model.
+
+- **tests/**: Contains unit tests for the application.
+  - **test_api.py**: Tests for API endpoints.
+
+- **requirements.txt**: Lists the dependencies required for the project.
+
+- **.env.example**: Template for environment variables.
+
+- **.gitignore**: Specifies files to be ignored by Git.
+
+- **Dockerfile**: Instructions for building a Docker image for the application.
+
+## Setup Instructions
+
+1. **Clone the Repository**: 
+   Clone the repository to your local machine.
+
+2. **Create a Virtual Environment**: 
+   Create a virtual environment to manage dependencies.
+   ```
+   python -m venv venv
+   ```
+
+3. **Activate the Virtual Environment**: 
+   Activate the virtual environment.
+   - On Windows:
+     ```
+     venv\Scripts\activate
+     ```
+   - On macOS/Linux:
+     ```
+     source venv/bin/activate
+     ```
+
+4. **Install Dependencies**: 
+   Install the required dependencies using pip.
+   ```
+   pip install -r requirements.txt
+   ```
+
+5. **Set Up Environment Variables**: 
+   Copy `.env.example` to `.env` and fill in the necessary values, including the Groq API key and model ID.
+
+6. **Run the Application**: 
+   Start the FastAPI application.
+   ```
+   uvicorn src.main:app --reload
+   ```
+
+## Usage
+
+- **Endpoint**: `/api/coding`
+- **Method**: `POST`
+- **Request Body**:
+  ```json
+  {
+    "provider_notes": "Your provider notes here."
+  }
+  ```
+
+- **Response**:
+  ```json
+  {
+    "icd_codes": [
+      {
+        "code": "ICD_CODE_1",
+        "explanation": "Explanation for ICD_CODE_1"
+      }
+    ],
+    "cpt_codes": [
+      {
+        "code": "CPT_CODE_1",
+        "explanation": "Explanation for CPT_CODE_1"
+      }
+    ]
+  }
+  ```
+
+## Deployment
+
+For deployment, you can use Docker to containerize the application. Follow the instructions in the Dockerfile to build and run the application in a containerized environment.
+
+## License
+
+This project is licensed under the MIT License. See the LICENSE file for more details.

requirements.txt

@@ -0,0 +1,5 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+groq==0.4.1
+pydantic==2.5.0
+python-dotenv==1.0.0

src/api/__init__.py

@@ -0,0 +1,3 @@
+# The contents of the file: /icd-cpt-model/icd-cpt-model/src/api/__init__.py
+
+# This file is intentionally left blank.

src/api/routes.py

@@ -0,0 +1,34 @@
+from fastapi import APIRouter, HTTPException
+import sys
+import os
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from models.request_models import ProviderNotesRequest
+from models.response_models import CodingResponse
+from services.groq_service import groq_service
+
+router = APIRouter(prefix="/api/v1", tags=["Medical Coding"])
+
+@router.post("/analyze", response_model=CodingResponse)
+async def analyze_provider_notes(request: ProviderNotesRequest):
+    """
+    Analyze provider notes and return ICD-10 and CPT codes with explanations.
+    
+    - **provider_notes**: The medical provider notes to analyze
+    
+    Returns ICD-10 codes, CPT codes, and explanations for each.
+    """
+    try:
+        result = await groq_service.analyze_provider_notes(request.provider_notes)
+        return CodingResponse(**result)
+    except ValueError as e:
+        raise HTTPException(status_code=422, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+@router.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "service": "ICD-CPT Coding API"}

src/config/__init__.py

@@ -0,0 +1,3 @@
+# The contents of the file: /icd-cpt-model/icd-cpt-model/src/config/__init__.py
+
+# This file is intentionally left blank.

src/config/settings.py

@@ -0,0 +1,17 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+class Settings:
+    GROQ_API_KEY: str = os.getenv("GROQ_API_KEY")
+    MODEL_ID: str = os.getenv("MODEL_ID")
+    
+    def __init__(self):
+        if not self.GROQ_API_KEY:
+            raise ValueError("GROQ_API_KEY not found in environment variables")
+        if not self.MODEL_ID:
+            raise ValueError("MODEL_ID not found in environment variables")
+
+settings = Settings()

src/main.py

@@ -0,0 +1,41 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import sys
+import os
+
+# Add current directory to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from api.routes import router
+
+app = FastAPI(
+    title="ICD-10 and CPT Coding API",
+    description="Analyzes medical provider notes and returns appropriate ICD-10 and CPT codes with explanations",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(router)
+
+@app.get("/")
+async def root():
+    return {
+        "message": "ICD-10 and CPT Coding API",
+        "docs": "/docs",
+        "health": "/api/v1/health"
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

src/models/__init__.py

@@ -0,0 +1,3 @@
+# The contents of the file: /icd-cpt-model/icd-cpt-model/src/models/__init__.py
+
+# This file is intentionally left blank.

src/models/request_models.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+
+class ProviderNotesRequest(BaseModel):
+    provider_notes: str = Field(
+        ..., 
+        description="The medical provider notes to analyze",
+        min_length=10,
+        example="Patient presents with acute bronchitis. Performed comprehensive examination and prescribed antibiotics."
+    )
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "provider_notes": "Patient presents with acute bronchitis. Cough for 5 days, productive with yellow sputum. Lung exam reveals diffuse wheezing. Prescribed azithromycin 500mg."
+            }
+        }
+
+class ProviderNote(BaseModel):
+    note: str
+
+class CodingResponse(BaseModel):
+    cpt_codes: list
+    cpt_explanation: str
+    icd_codes: list
+    icd_explanation: str

src/models/response_models.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel, Field
+from typing import List
+
+class ICDCode(BaseModel):
+    code: str = Field(..., description="ICD-10 diagnosis code")
+    description: str = Field(..., description="Description of the diagnosis")
+    explanation: str = Field(..., description="Explanation for why this code was selected")
+
+class CPTCode(BaseModel):
+    code: str = Field(..., description="CPT procedure code")
+    description: str = Field(..., description="Description of the procedure/service")
+    explanation: str = Field(..., description="Explanation for why this code was selected")
+
+class CodingResponse(BaseModel):
+    icd_codes: List[ICDCode] = Field(default_factory=list, description="List of ICD-10 codes")
+    cpt_codes: List[CPTCode] = Field(default_factory=list, description="List of CPT codes")
+    overall_summary: str = Field(..., description="Overall summary of coding decisions")
+    
+    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"
+            }
+        }

src/services/__init__.py

@@ -0,0 +1,3 @@
+# The contents of the file: /icd-cpt-model/icd-cpt-model/src/services/__init__.py
+
+# This file is intentionally left blank.

src/services/groq_service.py

@@ -0,0 +1,50 @@
+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__))))
+
+from config.settings import settings
+from utils.prompts import SYSTEM_PROMPT, create_user_prompt
+
+class GroqService:
+    def __init__(self):
+        self.client = Groq(api_key=settings.GROQ_API_KEY)
+        self.model_id = settings.MODEL_ID
+    
+    async def analyze_provider_notes(self, provider_notes: str) -> dict:
+        """
+        Analyze provider notes and return ICD and CPT codes with explanations
+        """
+        try:
+            # Create the chat completion with system and user prompts
+            chat_completion = self.client.chat.completions.create(
+                messages=[
+                    {
+                        "role": "system",
+                        "content": SYSTEM_PROMPT
+                    },
+                    {
+                        "role": "user",
+                        "content": create_user_prompt(provider_notes)
+                    }
+                ],
+                model=self.model_id,
+                temperature=0.1,  # Low temperature for consistent, factual outputs
+                response_format={"type": "json_object"}  # Force JSON response
+            )
+            
+            # Extract and parse the response
+            response_content = chat_completion.choices[0].message.content
+            parsed_response = json.loads(response_content)
+            
+            return parsed_response
+            
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Failed to parse JSON response from model: {str(e)}")
+        except Exception as e:
+            raise Exception(f"Error calling Groq API: {str(e)}")
+
+groq_service = GroqService()

src/utils/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally left blank.

src/utils/prompts.py

@@ -0,0 +1,46 @@
+SYSTEM_PROMPT = """You are a specialized medical coding assistant AI that analyzes clinical provider notes and assigns appropriate ICD-10 and CPT codes.
+
+CRITICAL INSTRUCTIONS:
+1. You MUST respond ONLY in valid JSON format as specified below
+2. Do NOT hallucinate or make up codes - only use codes you are confident about
+3. If you are uncertain about any code, do NOT include it in the response
+4. If you cannot find any relevant ICD or CPT codes, return empty arrays for those sections
+5. Always provide clear, evidence-based explanations for each code you assign
+6. Your response must be parseable JSON - do not add any text before or after the JSON object
+
+REQUIRED JSON FORMAT:
+{
+  "icd_codes": [
+    {
+      "code": "ICD-10 code",
+      "description": "Description of the diagnosis",
+      "explanation": "Detailed explanation of why this code was selected based on the provider notes"
+    }
+  ],
+  "cpt_codes": [
+    {
+      "code": "CPT code",
+      "description": "Description of the procedure/service",
+      "explanation": "Detailed explanation of why this code was selected based on the provider notes"
+    }
+  ],
+  "overall_summary": "Brief summary of the coding decisions"
+}
+
+CODING PRINCIPLES:
+- Only assign codes that are clearly supported by documentation in the provider notes
+- Be conservative - if unsure, omit the code rather than guess
+- Prioritize accuracy over quantity
+- Each explanation must reference specific details from the provider notes
+- If no relevant codes can be determined, respond with empty arrays
+
+Remember: Return ONLY the JSON object, nothing else."""
+
+def create_user_prompt(provider_notes: str) -> str:
+    """Create the user prompt with provider notes"""
+    return f"""Analyze the following provider notes and extract appropriate ICD-10 and CPT codes.
+
+PROVIDER NOTES:
+{provider_notes}
+
+Respond ONLY with the JSON object following the exact format specified in the system prompt."""

tests/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally left blank.

tests/test_api.py

@@ -0,0 +1,21 @@
+from fastapi.testclient import TestClient
+from src.main import app
+
+client = TestClient(app)
+
+def test_coding_endpoint():
+    provider_notes = {
+        "notes": "Patient has a fever and cough."
+    }
+    
+    response = client.post("/api/coding", json=provider_notes)
+    
+    assert response.status_code == 200
+    data = response.json()
+    
+    assert "CPT" in data
+    assert "ICD" in data
+    assert isinstance(data["CPT"], list)
+    assert isinstance(data["ICD"], list)
+    assert "explanation" in data["CPT"][0]
+    assert "explanation" in data["ICD"][0]