Delete thicc

thicc/ai_logic/config.py

@@ -1,121 +0,0 @@
-"""
-Configuration for LLM and RAG components.
-Supports both OpenAI and Ollama (local) providers.
-"""
-import os
-from pathlib import Path
-from typing import Optional, Literal
-
-# Load environment variables from .env file if it exists
-try:
-    from dotenv import load_dotenv
-    env_path = os.environ.get("THICC_ENV", Path(os.getcwd()) / ".env")
-    if env_path.exists():
-        print(f"Loading environment variables from {env_path}")
-        load_dotenv(env_path)
-except ImportError:
-    pass  # python-dotenv not installed, will use system environment variables
-
-
-# LLM Provider Selection
-# Supported: openai, ollama, llama_cpp
-LLM_PROVIDER: Literal["openai", "ollama", "llama_cpp"] = os.getenv("LLM_PROVIDER", "llama_cpp").lower()
-
-# OpenAI Configuration
-OPENAI_API_KEY: Optional[str] = os.getenv("OPENAI_API_KEY")
-OPENAI_MODEL: str = os.getenv("OPENAI_MODEL", "gpt-4o-mini")  # or "gpt-3.5-turbo"
-
-# Ollama Configuration
-OLLAMA_BASE_URL: str = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
-OLLAMA_MODEL: str = os.getenv("OLLAMA_MODEL", "llama3.2")  # or "mistral", "phi3", etc.
-
-
-# llama.cpp Configuration (OpenAI-compatible server)
-LLAMA_CPP_API_BASE: str = os.getenv("LLAMA_CPP_API_BASE", "http://192.168.0.28:8012/v1")
-LLAMA_CPP_MODEL: str = os.getenv("LLAMA_CPP_MODEL", "llama-2-7b-chat")
-
-# Embedding Configuration
-EMBEDDING_PROVIDER: Literal["openai", "ollama", "local"] = os.getenv("EMBEDDING_PROVIDER", "local").lower()
-OPENAI_EMBEDDING_MODEL: str = os.getenv("EMBEDDING_MODEL", "text-embedding-3-small")
-OLLAMA_EMBEDDING_MODEL: str = os.getenv("OLLAMA_EMBEDDING_MODEL", "nomic-embed-text")
-LOCAL_EMBEDDING_MODEL: str = os.getenv("LOCAL_EMBEDDING_MODEL", "all-MiniLM-L6-v2")
-
-# RAG Configuration
-VECTOR_STORE_PERSIST_DIR: str = os.getenv("VECTOR_STORE_DIR", "./chroma_db")
-CHUNK_SIZE: int = 500
-CHUNK_OVERLAP: int = 50
-
-# LLM Temperature (0.0 = deterministic, 1.0 = creative)
-TEMPERATURE: float = float(os.getenv("TEMPERATURE", "0.3"))
-
-def validate_config():
-    """Validate that required configuration is present based on provider."""
-    if LLM_PROVIDER == "openai":
-        if not OPENAI_API_KEY:
-            raise ValueError(
-                "LLM_PROVIDER is set to 'openai' but OPENAI_API_KEY environment variable is not set. "
-                "Please set it or change LLM_PROVIDER to 'ollama' or 'llama_cpp'."
-            )
-    elif LLM_PROVIDER == "ollama":
-        # Check if Ollama is accessible
-        try:
-            import requests
-            response = requests.get(f"{OLLAMA_BASE_URL}/api/tags", timeout=2)
-            if response.status_code != 200:
-                raise ValueError(
-                    f"Ollama server not accessible at {OLLAMA_BASE_URL}. "
-                    "Please start Ollama with: ollama serve"
-                )
-        except Exception as e:
-            raise ValueError(
-                f"Cannot connect to Ollama at {OLLAMA_BASE_URL}. "
-                f"Please start Ollama server with: ollama serve\n"
-                f"Error: {e}"
-            )
-    elif LLM_PROVIDER == "llama_cpp":
-        # Check if llama.cpp server is accessible
-        try:
-            import requests
-            response = requests.get(f"{LLAMA_CPP_API_BASE}/models", timeout=2)
-            if response.status_code != 200:
-                raise ValueError(
-                    f"llama.cpp server not accessible at {LLAMA_CPP_API_BASE}. "
-                    "Please start llama.cpp with OpenAI API compatibility."
-                )
-        except Exception as e:
-            raise ValueError(
-                f"Cannot connect to llama.cpp at {LLAMA_CPP_API_BASE}. "
-                f"Please start llama.cpp server with OpenAI API compatibility.\n"
-                f"Error: {e}"
-            )
-    else:
-        raise ValueError(
-            f"Invalid LLM_PROVIDER: {LLM_PROVIDER}. Must be 'openai', 'ollama', or 'llama_cpp'."
-        )
-
-def get_provider_info() -> dict:
-    """Get information about the current LLM provider configuration."""
-    if LLM_PROVIDER == "openai":
-        llm_model = OPENAI_MODEL
-        url = None
-    elif LLM_PROVIDER == "ollama":
-        llm_model = OLLAMA_MODEL
-        url = OLLAMA_BASE_URL
-        print(f"Ollama URL: {url}")
-    elif LLM_PROVIDER == "llama_cpp":
-        llm_model = LLAMA_CPP_MODEL
-        url = LLAMA_CPP_API_BASE
-    else:
-        llm_model = None
-        url = None
-    return {
-        "llm_provider": LLM_PROVIDER,
-        "llm_model": llm_model,
-        "embedding_provider": EMBEDDING_PROVIDER,
-        "embedding_model": (
-            LOCAL_EMBEDDING_MODEL if EMBEDDING_PROVIDER == "local"
-            else OLLAMA_EMBEDDING_MODEL if EMBEDDING_PROVIDER == "ollama"
-            else OPENAI_EMBEDDING_MODEL
-        ),
-        "provider_url": url,
-    }

thicc/ai_logic/intent_parser.py

@@ -1,80 +0,0 @@
-import os
-from typing import Optional
-
-import pandas as pd
-
-from .rag_service import get_rag_service
-from insurance.coverage_explainer import CoverageExplainer
-
-USE_LLM = os.getenv("USE_LLM", "true").lower() == "true"
-
-
-def parse_intent_simple(user_input: str, services_data: pd.DataFrame) -> Optional[str]:
-    """Simple rule-based intent parsing with coverage question support."""
-    user_input = user_input.lower()
-
-    # Check coverage questions first (not really used now, but harmless)
-    if CoverageExplainer.identify_coverage_question(user_input):
-        return "coverage_explanation"
-
-    # Check for help/list requests
-    if any(word in user_input for word in ["help", "support", "services", "available"]):
-        return "list_services"
-
-    # Service keyword matching - match service descriptions mentioned in the user input
-    res = services_data[
-        services_data["description"].apply(
-            lambda desc: desc.lower() in user_input
-        )
-    ]
-
-    if not res.empty:
-        return res.iloc[0]["intent"]
-
-    return None
-
-
-def parse_intent_with_llm(
-    user_input: str,
-    services_data: pd.DataFrame,
-    hospital_name: str = "Unknown Hospital",
-) -> Optional[str]:
-    """LLM-powered intent parsing with coverage question detection."""
-
-    # Coverage questions bypass RAG (though app.py already handles these first)
-    if CoverageExplainer.identify_coverage_question(user_input):
-        return "coverage_explanation"
-
-    try:
-        rag_service = get_rag_service()
-        rag_service.initialize_vector_store(
-            services_data,
-            hospital_name,
-            force_reload=False,
-        )
-        intent = rag_service.parse_intent_with_llm(user_input, services_data)
-        return intent
-
-    except Exception as e:
-        print(f"Error in LLM parsing: {e}. Falling back to simple parsing.")
-        return parse_intent_simple(user_input, services_data)
-
-
-def parse_intent(
-    user_input: str,
-    services_data: pd.DataFrame,
-    hospital_name: str = "Unknown Hospital",
-    use_llm: Optional[bool] = None,
-) -> Optional[str]:
-    """
-    Main intent parser - detects service requests or coverage questions.
-    Returns: service intent, "list_services", "coverage_explanation", or None.
-    Note: coverage questions are already handled in app.py before this is called.
-    """
-    should_use_llm = use_llm if use_llm is not None else USE_LLM
-
-    if should_use_llm:
-        return parse_intent_with_llm(user_input, services_data, hospital_name)
-    else:
-        print("Using simple parsing.")
-        return parse_intent_simple(user_input, services_data)

thicc/ai_logic/rag_service.py

@@ -1,307 +0,0 @@
-"""
-RAG (Retrieval-Augmented Generation) service for healthcare cost information.
-
-This module provides semantic search capabilities over hospital services data
-using vector embeddings and LLM-powered query understanding.
-
-Supports both OpenAI and Ollama (local) LLM providers.
-"""
-import os
-from typing import List, Dict, Optional, Tuple
-import pandas as pd
-from pathlib import Path
-import textwrap
-
-from langchain_chroma import Chroma
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_core.documents import Document
-from langchain_core.prompts import ChatPromptTemplate
-
-from . import config
-
-
-def _get_llm():
-    """Get the appropriate LLM based on provider configuration."""
-    if config.LLM_PROVIDER == "openai":
-        from langchain_openai import ChatOpenAI
-        return ChatOpenAI(
-            model=config.OPENAI_MODEL,
-            temperature=config.TEMPERATURE,
-            openai_api_key=config.OPENAI_API_KEY
-        )
-    elif config.LLM_PROVIDER == "ollama":
-        from langchain_ollama import ChatOllama
-        return ChatOllama(
-            model=config.OLLAMA_MODEL,
-            temperature=config.TEMPERATURE,
-            base_url=config.OLLAMA_BASE_URL
-        )
-    else:
-        raise ValueError(f"Unsupported LLM provider: {config.LLM_PROVIDER}")
-
-
-def _get_embeddings():
-    """Get the appropriate embeddings based on provider configuration."""
-    if config.EMBEDDING_PROVIDER == "openai":
-        from langchain_openai import OpenAIEmbeddings
-        return OpenAIEmbeddings(
-            model=config.OPENAI_EMBEDDING_MODEL,
-            openai_api_key=config.OPENAI_API_KEY
-        )
-    elif config.EMBEDDING_PROVIDER == "ollama":
-        from langchain_ollama import OllamaEmbeddings
-        return OllamaEmbeddings(
-            model=config.OLLAMA_EMBEDDING_MODEL,
-            base_url=config.OLLAMA_BASE_URL
-        )
-    elif config.EMBEDDING_PROVIDER == "local":
-        from langchain_huggingface import HuggingFaceEmbeddings
-        return HuggingFaceEmbeddings(
-            model_name=config.LOCAL_EMBEDDING_MODEL,
-            model_kwargs={'device': 'cpu'},
-            encode_kwargs={'normalize_embeddings': True}
-        )
-    else:
-        raise ValueError(f"Unsupported embedding provider: {config.EMBEDDING_PROVIDER}")
-
-
-class HealthcareRAGService:
-    """
-    RAG service for healthcare cost information retrieval and intent parsing.
-    
-    This service creates vector embeddings of hospital services and uses
-    semantic search to find relevant services based on user queries.
-    
-    Supports multiple LLM providers: OpenAI and Ollama (local).
-    """
-    
-    def __init__(self, persist_directory: str = config.VECTOR_STORE_PERSIST_DIR):
-        """
-        Initialize the RAG service.
-        
-        Args:
-            persist_directory: Directory to persist the vector store
-        """
-        config.validate_config()
-        self.persist_directory = persist_directory
-        self.embeddings = _get_embeddings()
-        self.llm = _get_llm()
-        self.vector_store: Optional[Chroma] = None
-        
-    def create_documents_from_services(
-        self, 
-        services_df: pd.DataFrame,
-        hospital_name: str
-    ) -> List[Document]:
-        """
-        Convert service data into LangChain Documents with metadata.
-        
-        Args:
-            services_df: DataFrame containing service information
-            hospital_name: Name of the hospital
-            
-        Returns:
-            List of Document objects
-        """
-        documents = []
-        
-        for _, row in services_df.iterrows():
-            content = textwrap.dedent(f"""
-                Service: {row['description']}
-                Intent: {row['intent']}
-                Hospital: {hospital_name}
-                Gross Charge: ${row['gross_charge']}
-                Negotiated Rate: ${row['negotiated_rate']}
-
-                This service provides {row['description'].lower()} at {hospital_name}.
-                Common queries: {row['intent'].replace('_', ' ')}
-            """)
-            
-            metadata = {
-                "intent": row['intent'],
-                "description": row['description'],
-                "gross_charge": float(row['gross_charge']),
-                "negotiated_rate": float(row['negotiated_rate']),
-                "hospital": hospital_name,
-            }
-            
-            documents.append(Document(page_content=content, metadata=metadata))
-        
-        return documents
-    
-    def initialize_vector_store(
-        self, 
-        services_df: pd.DataFrame,
-        hospital_name: str,
-        force_reload: bool = False
-    ):
-        """
-        Initialize or reload the vector store with service data.
-        
-        Args:
-            services_df: DataFrame containing service information
-            hospital_name: Name of the hospital
-            force_reload: If True, recreate the vector store even if it exists
-        """
-        # Create documents from services data
-        documents = self.create_documents_from_services(services_df, hospital_name)
-        
-        # Check if we should use existing vector store
-        if not force_reload and os.path.exists(self.persist_directory):
-            try:
-                self.vector_store = Chroma(
-                    persist_directory=self.persist_directory,
-                    embedding_function=self.embeddings
-                )
-                # Add new documents to existing store
-                self.vector_store.add_documents(documents)
-                return
-            except Exception as e:
-                print(f"Could not load existing vector store: {e}. Creating new one.")
-        
-        # Create new vector store
-        self.vector_store = Chroma.from_documents(
-            documents=documents,
-            embedding=self.embeddings,
-            persist_directory=self.persist_directory
-        )
-    
-    def parse_intent_with_llm(
-        self, 
-        user_query: str,
-        available_services: pd.DataFrame
-    ) -> Optional[str]:
-        """
-        Use LLM with RAG to parse user intent and match to available services.
-        
-        Args:
-            user_query: The user's natural language query
-            available_services: DataFrame of available services
-            
-        Returns:
-            The matched intent string or None if no match found
-        """
-        if self.vector_store is None:
-            raise ValueError("Vector store not initialized. Call initialize_vector_store first.")
-        
-        # Perform semantic search to find relevant services
-        search_results = self.vector_store.similarity_search_with_score(user_query, k=3)
-        context_services = []
-        for doc, score in search_results:
-            context_services.append({
-                "description": doc.metadata["description"],
-                "intent": doc.metadata["intent"],
-                "relevance_score": score
-            })
-        
-        # LLM Prompt for intent parsing
-        prompt_template = ChatPromptTemplate.from_messages([
-            (
-                "system",
-                textwrap.dedent("""You are a healthcare assistant helping users find medical services.
-                Your task is to understand the user's intent and match it to one of the available services.
-
-                Available services from semantic search:
-                {context}
-
-                Instructions:
-                1. Analyze the user's query carefully
-                2. Match it to the most relevant service from the context
-                3. Return ONLY the intent string (e.g., "mri_information", "xray_information")
-                4. If the user is asking for general help or a list of services, return "list_services"
-                5. If no service matches well, return "unknown"
-
-                Return only the intent string, nothing else.
-                """)
-            ),
-            ("user", "{query}")
-        ])
-        
-        context_text = "\n".join([
-            f"- {s['description']} (intent: {s['intent']}, relevance: {s['relevance_score']:.3f})"
-            for s in context_services
-        ])
-        
-        messages = prompt_template.format_messages(
-            context=context_text,
-            query=user_query
-        )
-        response = self.llm.invoke(messages)
-        intent = response.content.strip()
-        
-        if intent == "list_services" or intent == "unknown":
-            return intent if intent == "list_services" else None
-
-        if intent in available_services["intent"].values:
-            return intent
-        
-        # Try partial matching intents
-        for service_intent in available_services["intent"].values:
-            if intent.lower() in service_intent.lower() or service_intent.lower() in intent.lower():
-                return service_intent
-        
-        return None
-    
-    def get_conversational_response(
-        self,
-        user_query: str,
-        service_info: Optional[Dict] = None,
-        plan_name: str = "No Insurance"
-    ) -> str:
-        """
-        Generate a natural, conversational response using the LLM.
-        
-        Args:
-            user_query: User's original query
-            service_info: Information about the matched service (if any)
-            plan_name: User's insurance plan name
-            
-        Returns:
-            Natural language response
-        """
-        if service_info is None:
-            prompt_template = ChatPromptTemplate.from_messages([
-                (
-                    "system",
-                    textwrap.dedent("""
-                    You are a helpful healthcare cost estimator assistant.
-                    The user asked about a service we don't have information for.
-                    Politely let them know and suggest they ask about available services.
-                    """)
-                ),
-                ("user", "{query}")
-            ])
-            messages = prompt_template.format_messages(query=user_query)
-        else:
-            prompt_template = ChatPromptTemplate.from_messages([
-                (
-                    "system",
-                    textwrap.dedent("""You are a helpful healthcare cost assistant.
-                    Provide a clear, friendly response about the service cost.
-
-                    Service Information:
-                    - Description: {description}
-                    - Estimated Cost: ${cost:.2f}
-                    - Insurance Plan: {plan}
-                    - Gross Charge: ${gross_charge}
-                    - Negotiated Rate: ${negotiated_rate}
-
-                    Provide a natural, conversational response that includes the estimated cost and any relevant details.""")
-                ),
-                ("user", "{query}")
-            ])
-            messages = prompt_template.format_messages(
-                description=service_info.get("description", "Unknown"),
-                cost=service_info.get("estimated_cost", 0),
-                plan=plan_name,
-                gross_charge=service_info.get("gross_charge", 0),
-                negotiated_rate=service_info.get("negotiated_rate", 0),
-                query=user_query
-            )
-        
-        response = self.llm.invoke(messages)
-        return response.content.strip()
-
-
-def get_rag_service() -> HealthcareRAGService:
-    return HealthcareRAGService()

thicc/app.py

@@ -1,164 +0,0 @@
-import gradio as gr
-from ai_logic.intent_parser import parse_intent
-from data.data_loader import list_services, load_services_data, HOSPITALS
-from insurance import plans, cost_estimator
-from insurance.coverage_explainer import CoverageExplainer
-
-# UI dropdowns
-plan_dropdown = gr.Dropdown(
-    choices=list(plans.SAMPLE_PLANS.keys()) + ["No Insurance"],
-    value="PPO",
-    label="Select plan",
-)
-
-hospital_dropdown = gr.Dropdown(
-    choices=list(HOSPITALS.keys()),
-    value=list(HOSPITALS.keys())[0],
-    label="Select a Hospital",
-)
-
-
-def respond(message, history, plan_name: str, hospital_name: str) -> str:
-    """Main response function - handles cost estimation and coverage explanations."""
-
-    # --- 1) Coverage questions first ---
-    if CoverageExplainer.identify_coverage_question(message):
-        # Figure out which term (deductible, copay, coinsurance, etc.)
-        term = CoverageExplainer.get_matching_term(message)
-
-        if term:
-            # Explain the specific term (NOT the whole message)
-            explanation = CoverageExplainer.explain_term(term)
-
-            # Add plan-specific context if a sample plan is selected
-            if plan_name != "No Insurance" and plan_name in plans.SAMPLE_PLANS:
-                plan = plans.SAMPLE_PLANS[plan_name]
-                plan_details = {
-                    "deductible": plan.deductible,
-                    "copay": plan.copay,
-                    "coinsurance": plan.coinsurance,
-                }
-                explanation += "\n\n---\n\n"
-                explanation += CoverageExplainer.format_plan_coverage_summary(
-                    plan_name, plan_details
-                )
-
-            return explanation
-        else:
-            # If we can't match a specific term, give the full coverage explainer
-            return CoverageExplainer.explain_all_terms()
-
-    # --- 2) Service cost estimation path ---
-    hospital_data_path = HOSPITALS.get(hospital_name)
-    services_data = load_services_data(hospital_data_path)
-    requested_info = parse_intent(message, services_data, hospital_name=hospital_name)
-
-    if requested_info is None or requested_info == "list_services":
-        services_list = list_services(services_data)
-        response = (
-            "**Available services:**\n"
-            + "\n".join(f"• {service}" for service in services_list)
-        )
-        response += (
-            "\n\n💡 **Tip**: You can ask me about insurance terms like "
-            "'What is a deductible?' or 'Explain coinsurance'."
-        )
-        return response
-
-    service_data = services_data[
-        services_data["intent"].str.contains(requested_info, case=False, na=False)
-    ]
-
-    if service_data.empty:
-        return (
-            "Sorry, no information found for your request.\n\nYou can:\n"
-            "• Ask about available services\n"
-            "• Ask about insurance terms (e.g., 'What is a copay?')\n"
-            "• Get cost estimates for specific procedures"
-        )
-
-    service_description = service_data.iloc[0]["description"]
-    price = service_data.iloc[0]["negotiated_rate"]
-
-    # Map dropdown choice -> InsurancePlan object
-    if plan_name == "No Insurance":
-        plan = plans.NO_INSURANCE_PLAN
-    else:
-        plan = plans.SAMPLE_PLANS.get(plan_name, plans.NO_INSURANCE_PLAN)
-
-    cost = cost_estimator.estimate_cost(price, plan, deductible_met=True)
-
-    # --- 3) Format response with cost breakdown ---
-
-    # Special handling for No Insurance so messaging isn't confusing
-    if plan_name == "No Insurance":
-        response = f"""**Cost Estimate for {service_description}**
-
-• Hospital: {hospital_name}
-• Insurance Plan: {plan_name}
-• Estimated Cost: **${cost:.2f}**
-
-Because you selected **No Insurance**, this demo assumes you pay the full negotiated rate.
-
-💡 **Understanding your cost**:
-• Negotiated rate: ${price:.2f}
-• Your insurance covers: $0.00
-• You pay: ${cost:.2f}
-
-If you want to see how deductibles, copays, and coinsurance work, switch to a sample plan above and ask something like:
-• "What is a deductible?"
-• "Explain coinsurance"
-"""
-        return response
-
-    # For actual plans
-    response = f"""**Cost Estimate for {service_description}**
-
-• Hospital: {hospital_name}
-• Insurance Plan: {plan_name}
-• Estimated Cost: **${cost:.2f}**
-
-This estimate assumes your deductible has been met. 
-
-💡 **Understanding your cost**:
-• Negotiated rate: ${price:.2f}
-• Your insurance covers: ${price - cost:.2f}
-• You pay: ${cost:.2f}"""
-
-    # Explain payment type
-    if plan.copay and cost == plan.copay:
-        response += (
-            f"\n\n*You're paying a fixed copay of ${plan.copay:.2f} for this service.*"
-        )
-    elif plan.coinsurance and plan.coinsurance > 0:
-        response += (
-            f"\n\n*You're paying {plan.coinsurance*100:.0f}% coinsurance "
-            f"({plan.coinsurance*100:.0f}% of ${price:.2f}).*"
-        )
-
-    response += (
-        "\n\n**Need help?** Ask me 'What is coinsurance?' "
-        "or any other insurance term!"
-    )
-
-    return response
-
-
-# Gradio interface (no examples table)
-demo = gr.ChatInterface(
-    fn=respond,
-    title="THICC Cost Chatbot - Now with Coverage Explanations! 🏥",
-    description="""Get healthcare cost estimates and understand your insurance coverage.
-    
-**What you can ask:**
-• Cost estimates: "How much does an MRI cost?"
-• Coverage terms: "What is a deductible?" or "Explain coinsurance"
-• Available services: "What services are available?"
-""",
-    type="messages",
-    additional_inputs=[plan_dropdown, hospital_dropdown],
-    additional_inputs_accordion="Tell us about your insurance plan and hospital",
-)
-
-if __name__ == "__main__":
-    demo.launch()

thicc/data/data_loader.py

@@ -1,31 +0,0 @@
-import pandas as pd
-from pathlib import Path
-
-# Directory of this file: .../thicc/data
-BASE_DIR = Path(__file__).resolve().parent
-
-HOSPITALS = {
-    "Mayo Clinic": BASE_DIR / "hospitals" / "mayo_clinic_data.csv",
-    "Cleveland Clinic": BASE_DIR / "hospitals" / "cleveland_clinic_data.csv",
-    "Johns Hopkins Hospital": BASE_DIR / "hospitals" / "johns_hopkins_hospital_data.csv",
-    "Massachusetts General Hospital": BASE_DIR / "hospitals" / "massachusetts_general_hospital_data.csv",
-    "UCLA Medical Center": BASE_DIR / "hospitals" / "ucla_medical_center_data.csv",
-    "Cedars-Sinai Medical Center": BASE_DIR / "hospitals" / "cedars_sinai_medical_center_data.csv",
-    "NewYork-Presbyterian Hospital": BASE_DIR / "hospitals" / "newyork_presbyterian_hospital_data.csv",
-    "Northwestern Memorial Hospital": BASE_DIR / "hospitals" / "northwestern_memorial_hospital_data.csv",
-    "UCSF Medical Center": BASE_DIR / "hospitals" / "ucsf_medical_center_data.csv",
-    "Houston Methodist Hospital": BASE_DIR / "hospitals" / "houston_methodist_hospital_data.csv",
-}
-
-def load_services_data(path) -> pd.DataFrame:
-    """Load price data from a CSV file."""
-    df = pd.read_csv(path)
-    return df[[
-        "intent",
-        "description",
-        "gross_charge",
-        "negotiated_rate",
-    ]]
-
-def list_services(services_data: pd.DataFrame) -> list[str]:
-    return services_data["description"].tolist()

thicc/data/hospitals/cedars_sinai_medical_center_data.csv

@@ -1,8 +0,0 @@
-intent,description,gross_charge,negotiated_rate
-"mri_information","MRI",1300,1080
-"xray_information","X-Ray",2180,1780
-"general_consultation","General Consultation",1620,1320
-"neurosurgery_information","Neurosurgery",20000,17000
-"pain_management_information","Pain Management",2500,2000
-"endocrinology_information","Endocrinology",3700,3100
-"bariatric_surgery_information","Bariatric Surgery",15000,12000

thicc/data/hospitals/cleveland_clinic_data.csv

@@ -1,6 +0,0 @@
-intent,description,gross_charge,negotiated_rate
-"mri_information","MRI",1320,1100
-"xray_information","X-Ray",2200,1800
-"general_consultation","General Consultation",1550,1250
-"cardiac_surgery_information","Cardiac Surgery",15000,12000
-"dialysis_information","Dialysis",4000,3200

thicc/data/hospitals/houston_methodist_hospital_data.csv

@@ -1,8 +0,0 @@
-intent,description,gross_charge,negotiated_rate
-"mri_information","MRI",1310,1090
-"xray_information","X-Ray",2130,1730
-"general_consultation","General Consultation",1610,1310
-"transplant_surgery_information","Transplant Surgery",48000,40000
-"wound_care_information","Wound Care",1800,1400
-"hyperbaric_therapy_information","Hyperbaric Therapy",3500,3000
-"occupational_therapy_information","Occupational Therapy",2100,1700

thicc/data/hospitals/johns_hopkins_hospital_data.csv

@@ -1,8 +0,0 @@
-intent,description,gross_charge,negotiated_rate
-"mri_information","MRI",1400,1150
-"xray_information","X-Ray",2050,1600
-"general_consultation","General Consultation",1700,1400
-"organ_transplant_information","Organ Transplant",50000,42000
-"pediatric_care_information","Pediatric Care",3000,2500
-"sleep_disorder_clinic_information","Sleep Disorder Clinic",2100,1700
-"infectious_disease_information","Infectious Disease",4200,3500

thicc/data/hospitals/massachusetts_general_hospital_data.csv

@@ -1,8 +0,0 @@
-intent,description,gross_charge,negotiated_rate
-"mri_information","MRI",1280,1050
-"xray_information","X-Ray",2150,1750
-"general_consultation","General Consultation",1650,1350
-"fertility_treatment_information","Fertility Treatment",12000,10000
-"oncology_information","Oncology",8000,7000
-"burn_unit_information","Burn Unit",6000,5000
-"speech_therapy_information","Speech Therapy",1800,1400

thicc/data/hospitals/mayo_clinic_data.csv

@@ -1,8 +0,0 @@
-intent,description,gross_charge,negotiated_rate
-"mri_information","MRI",1234,1000
-"xray_information","X-Ray",2100,1700
-"general_consultation","General Consultation",1600,1300
-"sleep_medicine_information","Sleep Medicine",2200,1800
-"rheumatology_information","Rheumatology",3500,2900
-"geriatrics_information","Geriatrics",2500,2000
-"nutrition_counseling_information","Nutrition Counseling",1200,900

thicc/data/hospitals/newyork_presbyterian_hospital_data.csv

@@ -1,8 +0,0 @@
-intent,description,gross_charge,negotiated_rate
-"mri_information","MRI",1370,1130
-"xray_information","X-Ray",2120,1720
-"general_consultation","General Consultation",1680,1380
-"psychiatric_care_information","Psychiatric Care",4000,3500
-"rehabilitation_information","Rehabilitation",2200,1800
-"neonatal_care_information","Neonatal Care",5000,4200
-"speech_pathology_information","Speech Pathology",2100,1700

thicc/data/hospitals/northwestern_memorial_hospital_data.csv

@@ -1,8 +0,0 @@
-intent,description,gross_charge,negotiated_rate
-"mri_information","MRI",1290,1060
-"xray_information","X-Ray",2170,1770
-"general_consultation","General Consultation",1630,1330
-"dermatology_information","Dermatology",1200,900
-"allergy_treatment_information","Allergy Treatment",1100,850
-"urology_information","Urology",2700,2200
-"pulmonology_information","Pulmonology",3500,2900

thicc/data/hospitals/ucla_medical_center_data.csv

@@ -1,8 +0,0 @@
-intent,description,gross_charge,negotiated_rate
-"mri_information","MRI",1350,1120
-"xray_information","X-Ray",2250,1850
-"general_consultation","General Consultation",1580,1280
-"sports_medicine_information","Sports Medicine",3500,3000
-"plastic_surgery_information","Plastic Surgery",9000,7500
-"immunology_information","Immunology",3200,2700
-"gastroenterology_information","Gastroenterology",4100,3500

thicc/data/hospitals/ucsf_medical_center_data.csv

@@ -1,8 +0,0 @@
-intent,description,gross_charge,negotiated_rate
-"mri_information","MRI",1390,1160
-"xray_information","X-Ray",2190,1790
-"general_consultation","General Consultation",1690,1390
-"aids_hiv_care_information","AIDS/HIV Care",7000,6000
-"genetic_counseling_information","Genetic Counseling",2500,2000
-"transgender_health_information","Transgender Health",6000,5000
-"integrative_medicine_information","Integrative Medicine",3200,2700

thicc/insurance/cost_estimator.py

@@ -1,13 +0,0 @@
-from .plans import InsurancePlan
-
-def estimate_cost(price: float, plan: InsurancePlan | None = None, deductible_met: bool = False) -> float:
-    price = float(price)
-
-    if plan is None or getattr(plan, "plan_name", "") == "No Insurance":
-        return price  # No insurance, full price
-
-    if deductible_met:
-        # If deductible is met, only copay and coinsurance apply
-        return plan.copay or (price * plan.coinsurance)
-
-    return min(price, plan.deductible) + plan.copay

thicc/insurance/coverage_explainer.py

@@ -1,248 +0,0 @@
-"""
-Coverage Explanations Module - Provides insurance term explanations.
-"""
-
-class CoverageExplainer:
-    """Explains insurance coverage terms in user-friendly language."""
-
-    COVERAGE_TERMS = {
-        "deductible": {
-            "brief": "The amount you pay before insurance starts covering costs",
-            "detailed": """A deductible is the amount you must pay out-of-pocket for covered healthcare services before your insurance plan starts to pay.
-
-**Example**: If you have a $1,000 deductible:
-• You pay the first $1,000 of covered services yourself
-• After meeting your deductible, you typically pay only copays or coinsurance
-• Deductibles reset yearly
-
-**Important**: Some services like preventive care may be covered before you meet your deductible.""",
-            "keywords": ["deductible", "deductibles", "yearly amount", "before insurance pays"],
-        },
-
-        "copay": {
-            "brief": "A fixed amount you pay for a covered service",
-            "detailed": """A copay (copayment) is a fixed amount you pay for a covered healthcare service, usually at the time of service.
-
-**Example**: 
-• Doctor visit: $25 copay
-• Specialist visit: $50 copay
-• Prescription: $10 copay
-
-**Key Points**:
-• Copays are typically the same regardless of the actual cost
-• You usually pay copays even after meeting your deductible
-• Different services have different copay amounts""",
-            "keywords": ["copay", "copayment", "fixed amount", "flat fee"],
-        },
-
-        "coinsurance": {
-            "brief": "Your percentage share of costs after deductible",
-            "detailed": """Coinsurance is your share of the costs of a covered healthcare service, calculated as a percentage of the allowed amount for the service.
-
-**Example**: With 20% coinsurance:
-• Insurance pays 80% of covered costs
-• You pay 20% of covered costs
-• This applies AFTER you meet your deductible
-
-**Real Scenario**: 
-MRI costs $1,000 (after deductible met)
-• Insurance pays: $800 (80%)
-• You pay: $200 (20%)""",
-            "keywords": ["coinsurance", "percentage", "percent of cost", "cost sharing", "80/20", "70/30"],
-        },
-
-        "out_of_network": {
-            "brief": "Higher costs for providers not in your insurance network",
-            "detailed": """Out-of-network refers to healthcare providers who haven't contracted with your insurance company to provide services at negotiated rates.
-
-**Penalties and Higher Costs**:
-• Higher deductibles (often double in-network amounts)
-• Higher coinsurance (40-50% vs 20-30%)
-• No negotiated rates (you may pay full price)
-• Balance billing (provider can bill you the difference)
-
-**Example Cost Difference**:
-Same procedure:
-• In-network: You pay $500 (20% coinsurance)
-• Out-of-network: You pay $2,000 (50% coinsurance + balance billing)
-
-**Tip**: Always check if a provider is in-network before receiving care, except in emergencies.""",
-            "keywords": [
-                "out of network",
-                "out-of-network",
-                "network penalties",
-                "provider network",
-                "in-network",
-                "network",
-            ],
-        },
-
-        "out_of_pocket_maximum": {
-            "brief": "The most you'll pay in a year for covered services",
-            "detailed": """The out-of-pocket maximum is the most you have to pay for covered services in a plan year. After you reach this amount, your insurance pays 100% of covered services.
-
-**What Counts**:
-✓ Deductibles
-✓ Copayments
-✓ Coinsurance
-
-**What Doesn't Count**:
-✗ Monthly premiums
-✗ Out-of-network costs (usually)
-✗ Non-covered services
-
-**Example**: $8,000 out-of-pocket maximum
-Once you've paid $8,000 in deductibles, copays, and coinsurance, your insurance covers 100% for the rest of the year.""",
-            "keywords": [
-                "out of pocket maximum",
-                "out-of-pocket maximum",
-                "max",
-                "maximum",
-                "yearly limit",
-                "annual limit",
-                "oop max",
-            ],
-        },
-
-        "premium": {
-            "brief": "Monthly payment to maintain insurance coverage",
-            "detailed": """Your premium is the amount you pay for your health insurance every month to maintain coverage, regardless of whether you use services.
-
-**Key Points**:
-• Due monthly whether you use healthcare or not
-• Doesn't count toward deductible or out-of-pocket maximum
-• Higher premiums often mean lower deductibles/copays
-• Employer may pay part of your premium
-
-**Example Monthly Premiums**:
-• Individual: $450/month
-• Family: $1,200/month""",
-            "keywords": ["premium", "monthly payment", "monthly cost", "insurance payment"],
-        },
-
-        "prior_authorization": {
-            "brief": "Insurance approval needed before certain services",
-            "detailed": """Prior authorization (preauthorization) means your insurance company must approve a service before you receive it for the service to be covered.
-
-**Common Services Requiring Authorization**:
-• MRI/CT scans
-• Surgery
-• Expensive medications
-• Specialist referrals (HMO plans)
-
-**Important**:
-• Without authorization, insurance may deny coverage
-• Your doctor typically handles the authorization
-• Can take days to weeks for approval
-• Emergency services don't require prior authorization""",
-            "keywords": [
-                "prior authorization",
-                "preauthorization",
-                "pre-approval",
-                "authorization",
-                "approval needed",
-            ],
-        },
-    }
-
-    @classmethod
-    def explain_term(cls, term: str) -> str | None:
-        """Get detailed explanation for a specific coverage term."""
-        term_lower = term.lower().strip()
-
-        for key, info in cls.COVERAGE_TERMS.items():
-            if key in term_lower or any(keyword in term_lower for keyword in info["keywords"]):
-                return info["detailed"]
-
-        return None
-
-    @classmethod
-    def get_brief_explanation(cls, term: str) -> str | None:
-        """Get brief explanation for a coverage term."""
-        term_lower = term.lower().strip()
-
-        for key, info in cls.COVERAGE_TERMS.items():
-            if key in term_lower or any(keyword in term_lower for keyword in info["keywords"]):
-                return info["brief"]
-
-        return None
-
-    @classmethod
-    def explain_all_terms(cls) -> str:
-        """Return explanations for all coverage terms."""
-        explanations = ["**Understanding Your Insurance Coverage**\n"]
-
-        for term, info in cls.COVERAGE_TERMS.items():
-            title = term.replace("_", " ").title()
-            explanations.append(f"**{title}**")
-            explanations.append(info["detailed"])
-            explanations.append("")
-
-        return "\n".join(explanations)
-
-    @classmethod
-    def identify_coverage_question(cls, user_input: str) -> bool:
-        """Check if user is asking about coverage terms."""
-        user_input_lower = user_input.lower()
-
-        # General coverage question patterns
-        general_terms = [
-            "what is",
-            "what's",
-            "explain",
-            "how does",
-            "how do",
-            "tell me about",
-            "help me understand",
-            "coverage",
-            "insurance terms",
-            "insurance work",
-        ]
-
-        # Check for general questions with coverage terms
-        if any(term in user_input_lower for term in general_terms):
-            for term_info in cls.COVERAGE_TERMS.values():
-                if any(keyword in user_input_lower for keyword in term_info["keywords"]):
-                    return True
-
-        # Direct term mentions
-        for term_info in cls.COVERAGE_TERMS.values():
-            if any(keyword in user_input_lower for keyword in term_info["keywords"]):
-                return True
-
-        return False
-
-    @classmethod
-    def get_matching_term(cls, user_input: str) -> str | None:
-        """Extract which coverage term the user is asking about."""
-        user_input_lower = user_input.lower()
-
-        for term_key, term_info in cls.COVERAGE_TERMS.items():
-            for keyword in term_info["keywords"]:
-                if keyword in user_input_lower:
-                    return term_key
-
-        return None
-
-    @classmethod
-    def format_plan_coverage_summary(cls, plan_name: str, plan_details: dict) -> str:
-        """Format a summary of coverage for a specific plan."""
-        deductible = plan_details.get("deductible", 0)
-        copay = plan_details.get("copay", 0)
-        coinsurance = plan_details.get("coinsurance", 0) * 100
-
-        return f"""**Your {plan_name} Plan Coverage**
-
-**Deductible**: ${deductible:,.0f}
-• You pay this amount first before insurance helps
-
-**Copay**: ${copay:.0f}
-• Fixed amount you pay per visit
-
-**Coinsurance**: {coinsurance:.0f}%
-• Your percentage share after deductible
-
-**How it works**:
-1. You pay 100% until you meet your ${deductible:,.0f} deductible
-2. Then you pay ${copay:.0f} copays or {coinsurance:.0f}% coinsurance
-3. Insurance covers the rest up to allowed amounts"""

thicc/insurance/plans.py

@@ -1,14 +0,0 @@
-class InsurancePlan:
-    def __init__(self, plan_name, copay, deductible, coinsurance):
-        self.plan_name = plan_name
-        self.copay = copay
-        self.deductible = deductible
-        self.coinsurance = coinsurance
-
-SAMPLE_PLANS = {
-    "HMO": InsurancePlan("HMO", 25, 0, 0.0),
-    "PPO": InsurancePlan("PPO", 20, 500, 0.2),
-    "HDHP": InsurancePlan("HDHP", 20, 1500, 0.1),
-}
-
-NO_INSURANCE_PLAN = InsurancePlan("No Insurance", 0, 0, 1.0)