cleanup

app.py

@@ -1,5 +1,16 @@
 """
 Gradio Web Interface for Harbor Treatment Navigation Chatbot
+
+Landing page offers three paths:
+1. Quick Recommendations — enter a zip code, get nearby options inline
+2. Talk to a Human — compact crisis callout with phone number
+3. Get Personalized Advice — leads to the AI chatbot
+
+Run locally:
+    python app.py
+
+Access in browser:
+    http://localhost:7860
 """
 
 import os
@@ -40,6 +51,20 @@ CSS = """
     font-style: italic;
 }
 
+/* ── Location Banner ── */
+.harbor-banner {
+    text-align: center;
+    font-size: 0.92rem;
+    font-weight: 600;
+    color: #0d6e6e;
+    background: #e6f7f7;
+    border: 1px solid #c8e6e6;
+    border-radius: 10px;
+    padding: 0.55rem 1rem;
+    margin-bottom: 1.5rem;
+    letter-spacing: 0.1px;
+}
+
 /* ── Cards ── */
 .harbor-card {
     background: #ffffff;
@@ -171,6 +196,23 @@ CSS = """
     padding: 0.4rem 0.9rem !important;
 }
 .chat-back-btn button:hover { background: #f0fafa !important; }
+
+/* ── Chat input area ── */
+.gradio-chatinterface > div:last-child,
+footer,
+.chatbot-input-row,
+[data-testid="chatbot"] ~ div {
+    padding: 0 1.25rem 1.25rem !important;
+}
+.gradio-chatinterface .input-row,
+.gradio-chatinterface form {
+    margin: 0.75rem 2rem 1.5rem !important;
+    border: 1.5px solid #c8e6e6 !important;
+    border-radius: 14px !important;
+    padding: 0.5rem !important;
+    box-shadow: 0 2px 10px rgba(13, 110, 110, 0.07) !important;
+    background: #ffffff !important;
+}
 """
 
 # ── Theme ─────────────────────────────────────────────────────────────────────
@@ -229,29 +271,40 @@ ZIPCODE_RE = re.compile(r"^\d{5}$")
 
 
 def is_valid_zip(zipcode: str) -> bool:
+    """Return True if zipcode is exactly 5 digits."""
     return bool(ZIPCODE_RE.match(zipcode.strip()))
 
 
 def _load_resources_once():
+    """Load resource CSVs once and cache."""
     if not hasattr(_load_resources_once, "_cache"):
         current_dir = os.path.dirname(os.path.abspath(__file__))
         paths = [
             os.path.join(current_dir, "references", "knowledge", "ma_resources.csv"),
-            os.path.join(current_dir, "references", "knowledge", "boston_resources.csv"),
+            os.path.join(current_dir, "references", "knowledge", "resources", "boston_resources.csv"),
         ]
         _load_resources_once._cache = load_resources(paths)
     return _load_resources_once._cache
 
 
 def get_recommendations(zipcode: str) -> list[dict]:
+    """
+    Return a list of treatment recommendations for the given zip code.
+
+    Uses the same filter/score logic as the chatbot, but with a minimal
+    profile containing only the zipcode.
+    """
     profile = create_empty_profile()
     profile["logistics"]["zipcode"] = zipcode.strip()
+
     resources = _load_resources_once()
     filtered = filter_resources(resources, profile)
-    return score_resources(filtered, profile)
+    top = score_resources(filtered, profile)
+    return top
 
 
 def format_recommendations(zipcode: str, results: list[dict]) -> str:
+    """Render recommendations as an HTML snippet for display."""
     if not results:
         return (
             f"<div class='harbor-results'>"
@@ -265,10 +318,12 @@ def format_recommendations(zipcode: str, results: list[dict]) -> str:
     items_html = ""
     for r in results:
         name = r.get("name", "Unknown Facility")
+        # Build address from parts
         addr_parts = [r.get("address", ""), r.get("city", ""),
                       r.get("state", ""), r.get("zip", "")]
         address = ", ".join(p.strip() for p in addr_parts if p.strip())
         phone = r.get("phone", "").strip()
+        # Type from primary_focus
         focus = r.get("primary_focus", "").strip()
         type_label = ", ".join(
             v.strip().replace("_", " ").title() for v in focus.split("|")
@@ -300,13 +355,30 @@ def format_recommendations(zipcode: str, results: list[dict]) -> str:
 # ── App ───────────────────────────────────────────────────────────────────────
 
 def create_chatbot():
-    _load_resources_once()
-    chatbot = Chatbot()
-
-    def chat(message, history):
-        return chatbot.get_response(message)
+    """Creates the Harbor interface with a landing page and chatbot."""
+    _load_resources_once()          # pre-load CSVs so first zip lookup is fast
+
+    def chat(message, history, bot):
+        """
+        Generate a response for the current message using a per-session Chatbot.
+
+        Args:
+            message (str): The current message from the user
+            history (list): List of previous message dicts for this session
+            bot (Chatbot): The per-session Chatbot instance (held in gr.State)
+
+        Returns:
+            tuple: (updated history, cleared input, bot)
+        """
+        response = bot.get_response(message, history)
+        history = history + [
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": response},
+        ]
+        return history, gr.update(value=""), bot
 
     def handle_zip_submit(zipcode: str):
+        """Validate zip and return inline results HTML."""
         zipcode = zipcode.strip()
         if not is_valid_zip(zipcode):
             return gr.update(
@@ -314,31 +386,37 @@ def create_chatbot():
                 visible=True,
             )
         results = get_recommendations(zipcode)
+
+        # Log recommendations to console
         if results:
             print(f"[Harbor] Zip lookup ({zipcode}) — {len(results)} recommendation(s):")
             for i, r in enumerate(results, 1):
                 print(f"  {i}. {r.get('name', 'Unknown')} — {r.get('city', '')}, {r.get('state', '')} {r.get('zip', '')}")
         else:
             print(f"[Harbor] Zip lookup ({zipcode}) — no results found.")
-        return gr.update(value=format_recommendations(zipcode, results), visible=True)
 
-    def show_chat():
-        return gr.update(visible=False), gr.update(visible=True)
+        return gr.update(value=format_recommendations(zipcode, results), visible=True)
 
     def show_landing():
         return gr.update(visible=True), gr.update(visible=False)
 
-    with gr.Blocks(title="Harbor", theme=THEME, css=CSS) as demo:
+    OPENING_MESSAGE = (
+        "How can I support you today? You can share anything about what you're dealing with—mental health concerns, alcohol or drug use, support for a loved one, or help finding treatment resources."
+    )
+
+    with gr.Blocks(title="Harbor") as demo:
 
+        # ── Landing Page ──────────────────────────────────────────────
         with gr.Column(visible=True) as landing_page:
             with gr.Column(elem_classes="harbor-wrap"):
                 gr.HTML(HEADER_MD)
+                gr.HTML("<div class='harbor-banner'>📍 Find options near you in the Greater Boston, Massachusetts area.</div>")
 
+                # Card 1 — Quick Recommendations (featured)
                 with gr.Group(elem_classes="harbor-card harbor-card-featured"):
-                    gr.HTML("<div class='harbor-card-title'>📍 Find Options Near You</div>")
+                    gr.HTML("<div class='harbor-card-title'>🏠 Enter Your Zip Code</div>")
                     gr.HTML(
-                        "<p>Enter your zip code and we'll show you nearby treatment "
-                        "programs right away — no account needed.</p>"
+                        "<p>We'll show you nearby treatment programs right away, or talk to our chatbot below for better recommendations.</p>"
                     )
                     with gr.Row():
                         zip_input = gr.Textbox(
@@ -354,10 +432,14 @@ def create_chatbot():
                             scale=1,
                             elem_classes="harbor-zip-btn",
                         )
+                # Results rendered outside the card so the loading spinner
+                # does not overlay the input card above.
                 results_html = gr.HTML(visible=False, elem_id="zip-results")
 
+                # Card 2 — Crisis callout (compact)
                 gr.HTML(CRISIS_CALLOUT_HTML)
 
+                # Card 3 — Chatbot
                 with gr.Group(elem_classes="harbor-card"):
                     gr.HTML(CHATBOT_CARD_MD)
                     start_chat_btn = gr.Button(
@@ -369,7 +451,13 @@ def create_chatbot():
 
                 gr.HTML(FOOTER_MD)
 
+        # ── Chat Page ─────────────────────────────────────────────────
         with gr.Column(visible=False) as chat_page:
+            # Per-session state: a fresh Chatbot() is created for each browser session.
+            # Clicking "Start a Conversation" also resets it, so no data carries over
+            # between conversations on the same tab.
+            chatbot_state = gr.State(Chatbot)
+
             with gr.Column(elem_classes="chat-header"):
                 back_btn = gr.Button(
                     "← Back to Home",
@@ -377,33 +465,56 @@ def create_chatbot():
                     variant="secondary",
                     elem_classes="chat-back-btn",
                 )
-            gr.ChatInterface(
-                chat,
-                title="⚓ Harbor",
-                description=(
-                    "Tell me a little about your situation and I'll help you find "
-                    "treatment options that match your needs. Everything is confidential."
-                ),
-                examples=[
-                    "What treatment options are available near me?",
-                    "I'm looking for outpatient help with alcohol use.",
-                    "I need support but I don't have insurance.",
-                    "How do I know which type of program is right for me?",
-                ],
+            chatbot_display = gr.Chatbot(
+                value=[{"role": "assistant", "content": OPENING_MESSAGE}],
+                label="⚓ Harbor",
             )
+            with gr.Row():
+                msg_input = gr.Textbox(
+                    placeholder="Type your message here…",
+                    show_label=False,
+                    scale=8,
+                    container=False,
+                )
+                send_btn = gr.Button("Send →", variant="primary", scale=1)
 
+        def reset_bot_history(bot):
+            """Reset bot state and chatbot history while chat page is still hidden."""
+            bot.reset()
+            return bot, [{"role": "assistant", "content": OPENING_MESSAGE}]
+
+        def show_chat_page():
+            """Reveal chat page after bot has been reset — chatbot not in outputs, so no thinking indicator."""
+            return gr.update(visible=False), gr.update(visible=True)
+
+        # ── Events ────────────────────────────────────────────────────
         zip_btn.click(handle_zip_submit, inputs=zip_input, outputs=results_html)
         zip_input.submit(handle_zip_submit, inputs=zip_input, outputs=results_html)
-        start_chat_btn.click(show_chat, outputs=[landing_page, chat_page])
+
+        start_chat_btn.click(
+            reset_bot_history,
+            inputs=[chatbot_state],
+            outputs=[chatbot_state, chatbot_display],
+        ).then(
+            show_chat_page,
+            outputs=[landing_page, chat_page],
+        )
         back_btn.click(show_landing, outputs=[landing_page, chat_page])
 
+        send_btn.click(
+            chat,
+            inputs=[msg_input, chatbot_display, chatbot_state],
+            outputs=[chatbot_display, msg_input, chatbot_state],
+        )
+        msg_input.submit(
+            chat,
+            inputs=[msg_input, chatbot_display, chatbot_state],
+            outputs=[chatbot_display, msg_input, chatbot_state],
+        )
+
     return demo
 
 
 if __name__ == "__main__":
-    try:
-        demo = create_chatbot()
-        demo.launch()
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
+    demo = create_chatbot()
+    demo.launch(share=True, theme=THEME, css=CSS)

data/system_prompt.md

@@ -10,6 +10,12 @@ Scope / Boundaries
 
 Only assist with discovering and accessing mental health or substance use treatment services. If users ask unrelated questions, politely redirect the conversation back to treatment support.
 
+**Geographic Scope — Massachusetts only.** This service covers treatment facilities in Massachusetts, USA. If a user asks for help finding facilities outside Massachusetts, let them know clearly that this tool only covers Massachusetts. Do not recommend, name, or describe facilities in any other state or country. If the user's location turns out to be outside Massachusetts, acknowledge this limitation and offer to help if they are open to Massachusetts options.
+
+**Do not provide advice on medications, supplements, or eating/dietary behaviors.** If a user raises these topics, acknowledge what they've shared, affirm that these are important concerns, and explain that a treatment provider is the right person to help with those specifics — then redirect toward finding that provider.
+
+Your role is to build enough rapport to understand the user's needs and then match them to appropriate treatment. Do not attempt to process trauma or substitute for clinical care. Keep conversations moving toward matching — warmly but consistently.
+
 If a user indicates they may be in immediate crisis or danger, pause the normal conversation and encourage them to contact the Behavioral Health Help Line (BHHL).
 
 Crisis support information:
@@ -26,18 +32,48 @@ Tone / Style
 
 Be warm, patient, supportive, and non-judgmental. Use plain language and avoid clinical jargon.
 
-Use motivational interviewing techniques:
+Use motivational interviewing techniques throughout every exchange:
+
+\- **Reflect before you ask.** After each user message, acknowledge what they shared before moving to the next question. Mirror their language. Example: "It sounds like things have been really hard lately — thank you for trusting me with that."
 
-\- Ask open-ended questions
+\- **Elicit change talk early.** Ask what brought the user here today and what they’re hoping for, before asking about logistics. Example: "What made you decide to reach out today?" or "What would feel different in your life if you got support?"
 
-\- Reflect the user’s concerns
+\- **Affirm proactively and specifically.** Don’t wait for a milestone. Recognize effort as it happens. Example: "Reaching out takes real courage." "It sounds like you’ve been carrying a lot — you don’t have to figure this out alone." "That’s an important thing to know about yourself."
 
-\- Affirm their effort in seeking help
+\- **Normalize ambivalence.** If the user seems uncertain or hesitant, don’t push. Explore with curiosity: "It makes complete sense to have mixed feelings about this. What feels hardest about taking that step?"
 
-\- Avoid lecturing, pushing, or shaming
+\- **Roll with resistance.** If the user pushes back or isn’t ready, reflect their perspective and affirm their autonomy. Never argue or lecture.
+
+\- **Avoid lecturing, pushing, or shaming.**
 
 Respect the user’s autonomy and pace.
 
+Conversation Pacing
+
+Ask only ONE question at a time. Never stack multiple questions in a single response. Wait for the user to answer before asking the next question.
+
+**Matching Pacing Rule**: Do not spend more than 2–3 exchanges solely on rapport-building. By your 3rd or 4th response, you must begin collecting information needed for treatment matching (type of help, preferred setting, insurance/payment, location). You can do this warmly — weave the question into the conversation naturally — but do not delay beyond the 4th exchange.
+
+**NEVER use multiple-choice options (e.g., A/B/C lists, numbered menus, or bulleted option lists) in ANY follow-up response.** The opening message is the only place a structured menu appears. Every question you ask after that must be open-ended and conversational. This rule has no exceptions — not for treatment setting, insurance type, or any other field.
+
+Do Not Assume User Details
+
+Never assume, infer, or invent details about the user that they have not explicitly stated. This includes — but is not limited to — veteran status, insurance type, language preference, identity factors, location, substances used, or treatment history. If you need a piece of information to make a good recommendation, ask for it directly. Only reference information the user has already told you in this conversation.
+
+Handle Impossible or Contradictory User Details
+
+If a user provides information that is impossible, highly unlikely, internally inconsistent, clearly joking, or not usable for treatment matching (for example, "I am 3 years old," "I am 200 years old," or "find treatment on Mars"), do not proceed as if the information were correct. Do not shame, mock, or accuse the user of lying. Instead, briefly acknowledge the confusion, state that you may have misunderstood, and ask one calm open-ended question to clarify the relevant fact before continuing. Only continue with treatment matching once the information is realistic enough to support a safe and useful recommendation.
+
+Examples of when to clarify before continuing: impossible ages, contradictory statements, fake locations, non-human identities, clearly unserious treatment requests, or combinations of details that make matching unreliable.
+
+Preferred response style:
+
+\- "I may have misunderstood that. Could you tell me the age of the person who needs help?"
+
+\- "I want to make sure I understood correctly. What city are you looking for treatment in?"
+
+\- "Some of the details seem inconsistent, so I want to check before I suggest anything."
+
 Key Facts
 
 Users often hesitate to seek treatment due to stigma, fear, cost concerns, or uncertainty about what treatment involves.
@@ -68,44 +104,115 @@ Behavior Rules
 
 1\. Engage
 
-Build rapport and understand the user’s situation with open-ended questions.
+Build genuine rapport before collecting any logistics. Spend at least 1–2 exchanges understanding what brought the user here and what they’re hoping for.
+
+Begin by acknowledging the courage it takes to reach out. Ask open-ended questions about their situation and goals — not about insurance or zip code. Examples:
+
+\- "What’s been going on for you lately?"
+
+\- "What made today the day you decided to look into this?"
+
+\- "Who are you hoping to get support for — yourself, or someone you care about?"
+
+Only move to assessment after the user feels heard.
 
 2\. Educate
 
-If the user is uncertain about treatment, normalize help-seeking and explain what treatment typically involves.
+If the user is uncertain about treatment, normalize help-seeking and explain what specific treatment options are available and what treatment typically involves.
 
 3\. Assess
 
-Ask a short set of questions to understand their needs:
+If a USER PROFILE section appears above, treat those fields as already confirmed — do NOT ask the user again for any information already listed there. Only ask for fields that are still missing.
 
-\- type of help
+Before presenting any facility recommendations, make sure you have gathered all four of the following pieces of information. Collect them one at a time — do not ask more than one question per message. Ask each as a plain open-ended question — do NOT list options like A/B/C or bullet choices:
 
-\- treatment setting
+\- **Type of help needed** (substance use, mental health, or both)
 
-\- payment method
+\- **Preferred treatment setting** (outpatient, intensive outpatient, residential, or telehealth)
 
-\- location
+\- **Payment method or insurance** (private insurance, Medicaid/Medicare, VA/TRICARE, or uninsured/self-pay)
+
+\- **Location** (zip code or city/region)
+
+After collecting those four, also ask about any special preferences that may affect matching:
+
+\- Language preference
 
-\- optional preferences
+\- LGBTQ+ affirming care
+
+\- Veterans services
+
+\- Adolescent or youth services
+
+\- Pregnancy-related or postpartum care
+
+Frame each assessment question as caring about their experience, not collecting data. Do not ask bare factual questions. Instead:
+
+\- Rather than "What is your insurance?" → "I want to make sure we find options that actually work for your situation — do you have insurance, or would you be looking at other ways to cover the cost?"
+
+\- Rather than "What treatment setting do you prefer?" → "Some people find it works better to go to a program during the day and come home at night — others need more intensive support. What feels right for you, or what has worked before?"
+
+After collecting each piece of information, briefly acknowledge it before asking the next question.
+
+Do NOT present facility recommendations until all four required fields above have been collected — unless the user explicitly asks to see options early (e.g., "just show me what’s available" or "can you give me recommendations now?"). In that case, present what you have and note that results may improve with more information.
 
 4\. Match
 
 Present 3–5 treatment facilities that best match the user’s needs. Explain why each facility fits.
 
+Immediately after listing the facilities, ask the user which one they’d like to reach out to (open-ended — do not list options). Then, in that same response, include both of the following:
+
+**Call script** — a short, plain-language script the user can read aloud when they call, for example:
+
+> "Hi, my name is [Name]. I’m looking for [type of support] and I was wondering if you’re currently accepting new clients. I have [insurance / am self-pay]. Can you tell me about your intake process?"
+
+Tailor the script to reflect what the user has shared (their insurance, type of support needed, etc.).
+
+**What to expect on the call** — briefly explain what the facility will likely ask, such as:
+
+\- Their name and contact information
+\- The type of help they’re seeking (substance use, mental health, or both)
+\- Their insurance provider or ability to pay
+\- Their location or transportation situation
+\- Whether they’ve been in treatment before
+\- Any urgent safety concerns or current substance use
+
+Reassure the user that these questions are routine, not judgmental, and that they don’t have to have all the answers ready.
+
 5\. Empower
 
 Explain what happens when contacting a facility and what the intake process usually looks like.
 
 6\. Plan
 
-Encourage a concrete next step, such as calling a facility. Provide a simple call script.
+Encourage a concrete next step and help the user form a specific plan — not just an intention. People who decide *when*, *where*, and *how* they will act are significantly more likely to follow through.
+
+Ask:
+
+\- "When do you think you could make that call — tomorrow morning, or later this week?"
+
+\- "Where will you be when you call? Is there a place where you'd feel comfortable making it?"
+
+\- "Is there anything that might get in the way of making that call?" Then help them think through how to handle that barrier.
+
+Provide a simple call script tailored to what the user has shared.
 
 7\. Follow-through
 
-Offer encouragement and help the user make a plan for when they will contact the facility.
+Close with genuine encouragement that names what the user has done in this conversation. Reference something specific they said. Example: "You came here today knowing something needed to change — that matters."
+
+Ask one barrier-coping question: "What might make it hard to follow through, and what could you do if that happens?" Help them think through a backup plan.
+
+Remind them they can come back if they need more help or if circumstances change.
 
 Guardrails
 
+Scope of Role
+
+Remember at all times: your primary purpose is to match users to treatment options, not to provide therapy, counseling, or clinical guidance. Rapport-building is a means to that end — use it to earn trust so users will engage with the matching process. If a conversation drifts into extended emotional processing, gently acknowledge the user's feelings and redirect toward identifying their treatment needs. You are a navigator, not a clinician.
+
+Never recommend, advise on, or comment on specific medications (prescription or over-the-counter), dosages, or dietary/eating behaviors. If a user asks about these topics or describes struggles with them (e.g., disordered eating, self-medicating), validate their concern and let them know a treatment provider is the right person to address it — then continue guiding them toward finding that provider.
+
 Source of Truth
 
 Only recommend facilities that come from an approved, up-to-date treatment directory or database provided to the assistant. Do not invent, infer, or guess facility names, addresses, phone numbers, hours, or services. If verified facility data is unavailable, say so clearly and offer general guidance instead.
@@ -172,8 +279,6 @@ Call or text: 833-773-2445
 
 Trained counselors can talk with you and help figure out the next step.
 
-If you'd like, you can also tell me a little about what's happening and I can help you think through what to do next.
-
 Output Format
 
 When recommending facilities, present them clearly:

requirements.txt

@@ -1,7 +1,10 @@
-gradio>=4.0.0
-transformers>=5.0.0
-torch>=2.0.0
-accelerate>=0.26.0
-bitsandbytes>=0.46.1
-huggingface_hub>=0.20.0
-python-dotenv
+torch>=2.1.0
+transformers>=4.34.0
+datasets>=2.14.0
+accelerate>=0.24.0
+sentencepiece>=0.1.99
+gradio>=3.50.0
+huggingface-hub>=0.19.0
+numpy<2.0.0
+ipywidgets>=8.0.0
+python-dotenv>=1.1.0

src/chat.py

@@ -1,124 +1,247 @@
+from huggingface_hub import InferenceClient
+from src.config import BASE_MODEL, MY_MODEL, HF_TOKEN
 import os
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
-from src.config import BASE_MODEL, MY_MODEL, LOCAL_MODEL, HF_TOKEN
-from src.utils.profile import (
-    load_schema, create_empty_profile,
-    extract_profile_updates, merge_profile, profile_to_summary,
+from src.utils.tags import tag_user_input
+from src.utils.profile import load_schema, create_empty_profile, extract_profile_updates, merge_profile, profile_to_summary
+from src.utils.resources import load_resources, filter_resources, score_resources, format_resources_for_context
+
+RECOMMENDATION_KEYWORDS = [
+    "show me", "show options", "show recommendations", "give me options",
+    "what options", "what facilities", "find me", "recommend", "recommendations",
+    "options near", "what's available", "what is available", "what are my options",
+    "just show", "see options", "see recommendations", "list options",
+    "i want to see", "can you show", "what do you have",
+]
+
+REQUIRED_PROFILE_FIELDS = [
+    ("clinical", "primary_focus"),      # type of help
+    ("preferences", "setting"),         # treatment setting
+    ("logistics", "insurance"),         # payment / insurance
+]
+
+
+def _has_enough_for_recommendation(profile: dict) -> bool:
+    """Return True when the four key fields are collected."""
+    for category, field in REQUIRED_PROFILE_FIELDS:
+        value = profile.get(category, {}).get(field)
+        if not value:
+            return False
+    # location: either zipcode or region
+    zipcode = profile.get("logistics", {}).get("zipcode")
+    region = profile.get("logistics", {}).get("region")
+    if not zipcode and not region:
+        return False
+    return True
+
+
+def _user_wants_recommendations(user_input: str) -> bool:
+    """Return True if the user is explicitly asking for recommendations."""
+    lower = user_input.lower()
+    return any(kw in lower for kw in RECOMMENDATION_KEYWORDS)
+
+
+CRISIS_KEYWORDS = [
+    "suicid", "kill myself", "want to die", "end my life", "take my life",
+    "don't want to live", "dont want to live", "no reason to live",
+    "better off dead", "self-harm", "self harm", "hurt myself", "cutting myself",
+    "overdose", "overdosing",
+]
+
+CRISIS_RESPONSE = (
+    "I'm really sorry you're going through something this difficult. "
+    "You don't have to handle it alone.\n\n"
+    "Please reach out for immediate support:\n\n"
+    "**Behavioral Health Help Line (BHHL)**\n"
+    "📞 Call or text: **833-773-2445**\n"
+    "Available 24 hours a day, 7 days a week, 365 days a year.\n"
+    "Anyone may contact the Help Line if they or a family member are experiencing "
+    "a mental health or substance use disorder crisis.\n\n"
+    "If you or someone near you may be in immediate danger, please call **911** right now."
 )
-from src.utils.resources import load_resources, filter_resources, score_resources, format_recommendations
-
-
-def _load_pipeline(model_id: str):
-    """Load a text-generation pipeline, using the best available device."""
-    print(f"[Harbor] Loading model: {model_id}")
-    tokenizer = AutoTokenizer.from_pretrained(model_id, token=HF_TOKEN)
-
-    if torch.cuda.is_available():
-        dtype = torch.bfloat16
-        device_map = "auto"
-        device = None
-        device_label = "CUDA"
-    elif torch.backends.mps.is_available():
-        # bitsandbytes does not support MPS; float16 on 18 GB can OOM.
-        # Fall back to CPU with float32.
-        dtype = torch.float32
-        device_map = None
-        device = -1
-        device_label = "CPU"
-    else:
-        dtype = torch.float32
-        device_map = None
-        device = -1
-        device_label = "CPU"
-
-    model = AutoModelForCausalLM.from_pretrained(
-        model_id,
-        dtype=dtype,
-        device_map=device_map,
-        token=HF_TOKEN,
-    )
-
-    pipe = pipeline(
-        "text-generation",
-        model=model,
-        tokenizer=tokenizer,
-        device=device,
-    )
-    print(f"[Harbor] Model ready on {device_label}: {model_id}")
-    return pipe, tokenizer
+
+
+def _is_crisis(text: str) -> bool:
+    lower = text.lower()
+    return any(kw in lower for kw in CRISIS_KEYWORDS)
 
 
 class Chatbot:
 
     def __init__(self):
-        # LOCAL_MODEL is used for local development to avoid OOM on 18 GB machines.
-        # On HF Spaces (CUDA), MY_MODEL (the merged finetuned model) is used.
-        model_id = LOCAL_MODEL or MY_MODEL or BASE_MODEL
-        self.pipe, self.tokenizer = _load_pipeline(model_id)
-
+        """
+        Initialize the chatbot with a HF model ID
+        """
+        model_id = MY_MODEL if MY_MODEL else BASE_MODEL # define MY_MODEL in config.py if you create a new model in the HuggingFace Hub
+        self.client = InferenceClient(model=model_id, token="HF_TOKEN")
+        # Initialize tag lists
+        self.user_tags = []
+        self.substance_tags = []
+        # Initialize user profile
         current_dir = os.path.dirname(os.path.abspath(__file__))
         data_dir = os.path.join(current_dir, '..', 'data')
         self.profile_schema = load_schema(os.path.join(data_dir, 'user_profile_schema.json'))
         self.user_profile = create_empty_profile()
-
+        # Load treatment resources once
         knowledge_dir = os.path.join(data_dir, '..', 'references', 'knowledge')
-        self.resources = load_resources([
+        resources_paths = [
             os.path.join(knowledge_dir, 'ma_resources.csv'),
-            os.path.join(knowledge_dir, 'boston_resources.csv'),
-        ])
+            os.path.join(knowledge_dir, 'resources', 'boston_resources.csv'),
+        ]
+        self.resources = load_resources(resources_paths)
 
-    def update_profile(self, user_input: str):
+    def reset(self):
+        """Reset conversation state for a new session without re-initializing the client or resources."""
+        self.user_tags = []
+        self.substance_tags = []
+        self.user_profile = create_empty_profile()
+
+    def update_profile(self, user_input):
+        """
+        Scan user input for profile-relevant information and merge it
+        into the running user profile.
+
+        Args:
+            user_input (str): The user's message text.
+        """
         updates = extract_profile_updates(self.profile_schema, user_input)
         merge_profile(self.user_profile, updates)
 
-    def format_prompt(self, user_input: str) -> list[dict]:
+    def format_prompt(self, user_input, turn_number=0):
+        """
+        Format the user's input into a list of chat messages with system context.
+        Also tags the input with relevant keywords and substances that appear in the text,
+        and updates the user profile with any new information detected.
+
+        This method:
+        1. Loads system prompt from system_prompt.txt
+        2. Detects keywords from keywords.txt in user input (case-insensitive, partial matches)
+        3. Detects substances from substances.txt in user input (case-insensitive, partial matches)
+        4. Updates user profile from schema-based keyword matching
+        5. Injects profile summary into the system prompt so the model knows what's been gathered
+        6. Returns a list of message dicts for the chat completion API
+
+        Args:
+            user_input (str): The user's question
+            turn_number (int): Zero-indexed turn count (0 = first user message)
+
+        Returns:
+            list[dict]: A list of message dicts with 'role' and 'content' keys
+        """
+        # Get the directory where this file is located
         current_dir = os.path.dirname(os.path.abspath(__file__))
+
+        # Load system prompt
         system_prompt_path = os.path.join(current_dir, '../data/system_prompt.md')
         with open(system_prompt_path, 'r', encoding='utf-8') as f:
             system_prompt = f.read().strip()
 
+        # Tag user input with keywords and substances
+        keywords_path = os.path.join(current_dir, '../data/keywords.txt')
+        substances_path = os.path.join(current_dir, '../data/substances.txt')
+
+        self.user_tags = tag_user_input(keywords_path, user_input)
+        self.substance_tags = tag_user_input(substances_path, user_input)
+
+        # Update user profile from this message
         self.update_profile(user_input)
+
+        # Build profile summary for the prompt
         profile_summary = profile_to_summary(self.user_profile)
 
+        # Build system message with profile context
         system_content = system_prompt
         if profile_summary:
-            system_content += "\n\n" + profile_summary
-
-        return [
-            {"role": "system", "content": system_content},
-            {"role": "user", "content": user_input},
-        ]
-
-    def get_response(self, user_input: str) -> str:
-        messages = self.format_prompt(user_input)
-
-        prompt = self.tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,
-            add_generation_prompt=True,
-        )
-        output = self.pipe(
-            prompt,
-            max_new_tokens=512,
+            system_content = system_content + "\n\n" + profile_summary
+
+        # On the 4th user message (turn_number >= 3), nudge the model to ask a matching question
+        if turn_number >= 3:
+            missing = []
+            clinical = self.user_profile.get("clinical", {})
+            preferences = self.user_profile.get("preferences", {})
+            logistics = self.user_profile.get("logistics", {})
+            if not clinical.get("primary_focus"):
+                missing.append("type of help needed (substance use, mental health, or both)")
+            if not preferences.get("setting"):
+                missing.append("preferred treatment setting")
+            if not logistics.get("insurance"):
+                missing.append("payment method or insurance")
+            if not logistics.get("zipcode") and not logistics.get("region"):
+                missing.append("location (zip code or city)")
+
+            if missing:
+                nudge = (
+                    "\n\n[PACING INSTRUCTION — DO NOT REPEAT TO USER] "
+                    "You have now had several exchanges. You MUST include a question relevant to "
+                    "treatment matching in this response. Ask about one of the following missing fields: "
+                    + "; ".join(missing)
+                    + ". Ask it warmly and conversationally — one question only."
+                )
+                system_content = system_content + nudge
+
+        # Return structured messages for chat completion API
+        messages = [{"role": "system", "content": system_content}]
+
+        return messages
+
+    def get_response(self, user_input, history=None):
+        """
+        Generate a response to the user's question, with resource recommendations
+        appended when the user profile contains enough information to match.
+
+        Args:
+            user_input (str): The user's question
+
+        Returns:
+            str: The chatbot's response, optionally followed by top 3 resources
+        """
+        # 0. Hard crisis check — bypass LLM entirely if crisis keywords detected
+        if _is_crisis(user_input):
+            print("[Harbor] Crisis keywords detected — returning crisis response.")
+            return CRISIS_RESPONSE
+
+        # 1. Format messages (also updates profile and tags)
+        turn_number = len(history) if history else 0
+        messages = self.format_prompt(user_input, turn_number=turn_number)
+
+        # 1b. After the user's first message, return a fixed follow-up instead of calling the LLM.
+        # Profile and tags have already been updated above so the first message is not lost.
+        if history and len(history) == 1:
+            return (
+                "Thank you for sharing that. Before I give you any recommendations, "
+                "can you tell me a little bit about you or the loved one you are concerned about?"
+            )
+
+        # 2. Inject verified facility data into the system prompt so the LLM presents
+        # recommendations naturally in its own voice — only when the profile has enough
+        # info or the user is explicitly asking for options.
+        if _has_enough_for_recommendation(self.user_profile) or _user_wants_recommendations(user_input):
+            filtered = filter_resources(self.resources, self.user_profile)
+            top = score_resources(filtered, self.user_profile)
+            if top:
+                facility_context = format_resources_for_context(top)
+                messages[0]["content"] = messages[0]["content"] + "\n\n" + facility_context
+            elif _has_enough_for_recommendation(self.user_profile):
+                messages[0]["content"] = messages[0]["content"] + (
+                    "\n\n[NOTE — No verified facilities matched the user's profile. "
+                    "Let the user know you couldn't find a direct match and ask if "
+                    "they'd be open to broader options.]"
+                )
+
+        # 3. Append conversation history then current user message
+        for item in (history or []):
+            if isinstance(item, dict):
+                messages.append({"role": item["role"], "content": item["content"]})
+            else:
+                human, assistant = item
+                messages.append({"role": "user", "content": human})
+                if assistant is not None:
+                    messages.append({"role": "assistant", "content": assistant})
+        messages.append({"role": "user", "content": user_input})
+
+        # 4. Generate LLM response via chat completion API
+        result = self.client.chat_completion(
+            messages=messages,
+            max_tokens=512,
             temperature=0.7,
-            do_sample=True,
-            return_full_text=False,
         )
-        response = output[0]["generated_text"].strip()
-
-        filtered = filter_resources(self.resources, self.user_profile)
-        top_resources = score_resources(filtered, self.user_profile)
-        recommendations = format_recommendations(top_resources)
-
-        if top_resources:
-            print(f"[Harbor] {len(top_resources)} recommendation(s) for current profile:")
-            for i, r in enumerate(top_resources, 1):
-                print(f"  {i}. {r.get('name', 'Unknown')} — {r.get('city', '')}, {r.get('state', '')} {r.get('zip', '')}")
-        else:
-            print("[Harbor] No recommendations matched current profile.")
-
-        if recommendations:
-            response += "\n\n" + recommendations
-
-        return response
+        return result.choices[0].message.content.strip()

src/config.py

@@ -12,10 +12,6 @@ BASE_MODEL = "Qwen/Qwen2.5-7B-Instruct"
 # BASE_MODEL = "HuggingFaceH4/zephyr-7b-beta"       # ungated
 
 # If you finetune the model or change it in any way, save it to huggingface hub, then set MY_MODEL to your model ID. The model ID is in the format "your-username/your-model-name".
-MY_MODEL = "amitashukla/harbor-qwn25-merged" 
-
-# Used locally to avoid OOM on 18 GB unified memory.
-# Set to None (or remove) when deploying to HF Spaces.
-LOCAL_MODEL = None #"Qwen/Qwen2.5-1.5B-Instruct"
+MY_MODEL = "" #"amitashukla/harbor-qwn25-lora"
 
 HF_TOKEN = os.getenv("HF_TOKEN")

src/utils/profile.py

@@ -221,4 +221,7 @@ def profile_to_summary(profile):
     if not lines:
         return ""
 
-    return "USER PROFILE (gathered so far):\n" + "\n".join(lines)
+    header = (
+        "USER PROFILE (already collected — DO NOT ask the user again for any of these details):\n"
+    )
+    return header + "\n".join(lines)

src/utils/resources.py

@@ -180,60 +180,63 @@ def score_resources(filtered, user_profile, top_n=3):
     return [row for _, row in scored[:top_n]]
 
 
-def format_recommendations(results):
+def format_resources_for_context(results):
     """
-    Format a list of resource dicts into a readable recommendation block.
-    Returns empty string if no results.
+    Format a list of resource dicts as a context block for injection into the
+    system prompt. The LLM uses this verified data to present recommendations
+    naturally in its own voice. Returns empty string if no results.
     """
     if not results:
         return ""
 
     lines = [
-        "---",
-        "Here are some resources that may be a good fit for you:",
+        "[VERIFIED FACILITY DATA — Present these facilities to the user following the "
+        "output format in your instructions. Use only the data listed here — do not invent, "
+        "alter, or supplement with facilities not in this list.]",
         "",
     ]
 
     for i, row in enumerate(results, 1):
         name = row.get("name", "Unknown Facility")
-        lines.append(f"{i}. {name}")
+        lines.append(f"Facility {i}: {name}")
 
-        # Address
         parts = [row.get("address", ""), row.get("city", ""),
                  row.get("state", ""), row.get("zip", "")]
         address = ", ".join(p.strip() for p in parts if p.strip())
         if address:
-            lines.append(f"   {address}")
+            lines.append(f"  Address: {address}")
 
-        # Phone
         phone = row.get("phone", "").strip()
         if phone:
-            lines.append(f"   Phone: {phone}")
+            lines.append(f"  Phone: {phone}")
 
-        # Website
         website = row.get("website", "").strip()
         if website:
-            lines.append(f"   Website: {website}")
+            lines.append(f"  Website: {website}")
 
-        # Summary line: focus, substances, settings
-        details = []
         focus = row.get("primary_focus", "").strip()
         if focus:
-            details.append("Focus: " + ", ".join(
+            lines.append("  Focus: " + ", ".join(
                 v.strip().replace("_", " ").title() for v in focus.split("|")
             ))
+
         subs = row.get("substances", "").strip()
         if subs:
-            details.append("Substances: " + ", ".join(
+            lines.append("  Substances: " + ", ".join(
                 v.strip().replace("_", " ").title() for v in subs.split("|")
             ))
+
         settings = row.get("settings", "").strip()
         if settings:
-            details.append("Settings: " + ", ".join(
+            lines.append("  Settings: " + ", ".join(
                 v.strip().replace("_", " ").title() for v in settings.split("|")
             ))
-        if details:
-            lines.append("   " + " | ".join(details))
+
+        insurance = row.get("insurance", "").strip()
+        if insurance:
+            lines.append("  Insurance: " + ", ".join(
+                v.strip().replace("_", " ").title() for v in insurance.split("|")
+            ))
 
         lines.append("")