Upload 19 files

thicc/ai_logic/config.py

@@ -0,0 +1,121 @@
+"""
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,307 @@
+"""
+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

@@ -0,0 +1,164 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,248 @@
+"""
+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

@@ -0,0 +1,14 @@
+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)