Update medication search and patient-friendly copy

assets/apple.css

@@ -358,6 +358,13 @@ body,
   opacity: 1 !important;
 }
 
+.medication-picker .options[role="listbox"] {
+  max-height: min(360px, calc(100vh - 160px)) !important;
+  overflow-y: auto !important;
+  overscroll-behavior: contain;
+  scrollbar-width: thin;
+}
+
 .button-row {
   gap: 12px;
   margin-top: 12px;

shared_app.py

@@ -14,8 +14,13 @@ from src.model_catalog import (
 )
 from src.prompts import build_prep_report_prompt
 from src.processor import validate_inputs, parse_prep_report
-from src.medications import load_medication_choices, medication_index_summary
+from src.medications import (
+    filter_medication_choices,
+    load_medication_choices,
+    medication_index_summary,
+)
 from config_loader import load_settings
+import gradio as gr
 
 settings = load_settings()
 
@@ -216,14 +221,14 @@ def run_inference(
     return parse_prep_report(report_raw)
 
 
-def add_medication_entry(medication_name: str, instructions: str, current_medications: str):
+def add_medication_entry(medication_name: str, instructions: str, current_medications: str, all_choices: list = None):
     """Append a selected or custom medication line to the medication list."""
     medication_name = (medication_name or "").strip()
     instructions = (instructions or "").strip()
     current_medications = (current_medications or "").strip()
 
     if not medication_name and not instructions:
-        return current_medications, "", "", None
+        return current_medications, "", "", gr.update(choices=all_choices or [], value=None)
 
     if medication_name and instructions:
         entry = f"{medication_name} - {instructions}"
@@ -231,7 +236,22 @@ def add_medication_entry(medication_name: str, instructions: str, current_medica
         entry = medication_name or instructions
 
     updated = f"{current_medications}\n{entry}".strip() if current_medications else entry
-    return updated, "", "", None
+    return updated, "", "", gr.update(choices=all_choices or [], value=None)
+
+
+def clear_all_inputs(all_choices: list):
+    """Clear all input fields and reset medication picker."""
+    return (
+        "",  # symptoms
+        "",  # notes
+        "",  # medications
+        "",  # medication_name
+        "",  # medication_instructions
+        gr.update(choices=all_choices or [], value=None),  # medication_picker
+        DEFAULT_OUTPUT,  # timeline_output
+        DEFAULT_OUTPUT,  # questions_output
+        DEFAULT_OUTPUT,  # relevant_output
+    )
 
 
 def populate_medication_name(selected_medication: str, current_name: str):
@@ -239,6 +259,11 @@ def populate_medication_name(selected_medication: str, current_name: str):
     return (selected_medication or current_name or "").strip()
 
 
+def filter_medication_picker_choices(all_choices: list[str], evt: gr.KeyUpData):
+    """Return fuzzy medication choices using the dropdown's current typed text."""
+    return gr.update(choices=filter_medication_choices(evt.input_value, all_choices))
+
+
 def create_ui() -> gr.Blocks:
     app_cfg = settings.get("app", {})
     model_cfg = settings.get("model", {})
@@ -257,7 +282,7 @@ def create_ui() -> gr.Blocks:
     temperature = _temperature_choice_value(
         selected_model_cfg.get("temperature", model_cfg.get("temperature", 0.3))
     )
-    medication_choices = load_medication_choices()
+    all_medication_choices = load_medication_choices()
     medication_summary = medication_index_summary()
     deployment = app_cfg.get("deployment", "local")
     is_local_deployment = deployment == "local"
@@ -312,8 +337,7 @@ def create_ui() -> gr.Blocks:
                     gr.HTML(
                         """
                         <div class="pane-heading">
-                            <p class="section-kicker">Input</p>
-                            <h2>Appointment details</h2>
+                            <h2>Tell us about your visit</h2>
                         </div>
                         """
                     )
@@ -340,7 +364,7 @@ def create_ui() -> gr.Blocks:
                     medication_picker = gr.Dropdown(
                         label="Find a Medication",
                         show_label=False,
-                        choices=medication_choices,
+                        choices=all_medication_choices,
                         value=None,
                         filterable=True,
                         allow_custom_value=True,
@@ -350,7 +374,7 @@ def create_ui() -> gr.Blocks:
                     medication_name = gr.Textbox(
                         label="Medication Name",
                         show_label=False,
-                        placeholder="Select from RxTerms above, or type a medication, vitamin, or supplement",
+                        placeholder="Select a medication above, or type any medication, vitamin, or supplement",
                         lines=1,
                         max_lines=2,
                         elem_classes=["apple-input"],
@@ -394,8 +418,7 @@ def create_ui() -> gr.Blocks:
                     gr.HTML(
                         """
                         <div class="pane-heading">
-                            <p class="section-kicker">Output</p>
-                            <h2>Prep report</h2>
+                            <h2>Your appointment prep</h2>
                         </div>
                         """
                     )
@@ -512,6 +535,17 @@ def create_ui() -> gr.Blocks:
             outputs=[model_status, download_model_btn],
             api_visibility="private",
         )
+        # Create a state variable to hold all medication choices for filtering
+        medication_choices_state = gr.State(all_medication_choices)
+
+        medication_picker.key_up(
+            fn=filter_medication_picker_choices,
+            inputs=[medication_choices_state],
+            outputs=[medication_picker],
+            show_progress="hidden",
+            trigger_mode="always_last",
+            api_visibility="private",
+        )
         medication_picker.change(
             fn=populate_medication_name,
             inputs=[medication_picker, medication_name],
@@ -520,13 +554,13 @@ def create_ui() -> gr.Blocks:
         )
         add_medication_btn.click(
             fn=add_medication_entry,
-            inputs=[medication_name, medication_instructions, medications],
+            inputs=[medication_name, medication_instructions, medications, medication_choices_state],
             outputs=[medications, medication_name, medication_instructions, medication_picker],
             api_visibility="private",
         )
         clear_btn.click(
-            fn=lambda: ("", "", "", "", "", None, DEFAULT_OUTPUT, DEFAULT_OUTPUT, DEFAULT_OUTPUT),
-            inputs=[],
+            fn=clear_all_inputs,
+            inputs=[medication_choices_state],
             outputs=[
                 symptoms,
                 notes,

src/medications.py

@@ -5,12 +5,17 @@ Medication autocomplete data helpers.
 from __future__ import annotations
 
 import json
+import re
+from difflib import SequenceMatcher
 from functools import lru_cache
 from pathlib import Path
 
 
 ROOT_DIR = Path(__file__).resolve().parents[1]
 INDEX_PATH = ROOT_DIR / "data" / "medications" / "rxterms_medications.json"
+COMMON_INDEX_PATH = ROOT_DIR / "data" / "medications" / "rxterms_medications_common.json"
+DEFAULT_MEDICATION_SEARCH_LIMIT = 120
+_NON_WORD_RE = re.compile(r"[^0-9a-z]+")
 
 
 COMMON_SUPPLEMENTS = [
@@ -35,11 +40,14 @@ COMMON_SUPPLEMENTS = [
 
 @lru_cache(maxsize=1)
 def load_medication_choices() -> list[str]:
-    """Return local RxTerms choices plus common supplement fallback choices."""
+    """Return local RxTerms choices (pruned to common medications) plus common supplement fallback choices."""
     choices: list[str] = []
 
-    if INDEX_PATH.exists():
-        with INDEX_PATH.open("r", encoding="utf-8") as handle:
+    # Use pruned common medications list if available, otherwise fall back to full list
+    index_to_use = COMMON_INDEX_PATH if COMMON_INDEX_PATH.exists() else INDEX_PATH
+    
+    if index_to_use.exists():
+        with index_to_use.open("r", encoding="utf-8") as handle:
             payload = json.load(handle)
         choices.extend(item["label"] for item in payload.get("medications", []))
 
@@ -52,13 +60,99 @@ def load_medication_choices() -> list[str]:
     return choices
 
 
+def _normalize_search_text(value: str) -> str:
+    normalized = _NON_WORD_RE.sub(" ", value.casefold())
+    return " ".join(normalized.split())
+
+
+def _compact_search_text(value: str) -> str:
+    return _normalize_search_text(value).replace(" ", "")
+
+
+def _best_sequence_ratio(query: str, choice: str) -> float:
+    search_terms = {_compact_search_text(choice)}
+    search_terms.update(
+        _compact_search_text(part)
+        for part in re.split(r"[\s()/,-]+", choice)
+        if len(part) >= 4
+    )
+    search_terms.discard("")
+    if not search_terms:
+        return 0.0
+
+    return max(SequenceMatcher(None, query, term).ratio() for term in search_terms)
+
+
+def _medication_match_score(query: str, choice: str) -> tuple[float, ...] | None:
+    normalized_query = _normalize_search_text(query)
+    compact_query = normalized_query.replace(" ", "")
+    normalized_choice = _normalize_search_text(choice)
+    compact_choice = normalized_choice.replace(" ", "")
+
+    if not normalized_query:
+        return (0, 0)
+
+    if normalized_choice.startswith(normalized_query):
+        return (0, len(normalized_choice))
+
+    words = normalized_choice.split()
+    word_prefix_positions = [
+        index for index, word in enumerate(words) if word.startswith(normalized_query)
+    ]
+    if word_prefix_positions:
+        return (1, word_prefix_positions[0], len(normalized_choice))
+
+    substring_index = normalized_choice.find(normalized_query)
+    if substring_index != -1:
+        return (2, substring_index, len(normalized_choice))
+
+    compact_index = compact_choice.find(compact_query)
+    if compact_index != -1:
+        return (3, compact_index, len(compact_choice))
+
+    sequence_ratio = _best_sequence_ratio(compact_query, choice)
+    if sequence_ratio >= 0.72:
+        return (4, -sequence_ratio, len(compact_choice))
+
+    return None
+
+
+def filter_medication_choices(
+    query: str,
+    choices: list[str],
+    limit: int | None = DEFAULT_MEDICATION_SEARCH_LIMIT,
+) -> list[str]:
+    """Return case-insensitive substring and fuzzy medication matches."""
+    if not query or not query.strip():
+        return list(choices)
+
+    matches = []
+    for index, choice in enumerate(choices):
+        score = _medication_match_score(query, choice)
+        if score is not None:
+            matches.append((score, index, choice))
+
+    matches.sort()
+    filtered = [choice for _score, _index, choice in matches]
+    return filtered[:limit] if limit is not None else filtered
+
+
 def medication_index_summary() -> str:
-    if not INDEX_PATH.exists():
-        return "Medication autocomplete index is not installed."
+    # Prefer common index if available
+    index_to_use = COMMON_INDEX_PATH if COMMON_INDEX_PATH.exists() else INDEX_PATH
+    
+    if not index_to_use.exists():
+        return "You can type any medication, vitamin, or supplement below."
 
-    with INDEX_PATH.open("r", encoding="utf-8") as handle:
+    with index_to_use.open("r", encoding="utf-8") as handle:
         payload = json.load(handle)
+    count = int(payload.get("count", 0))
+    if count >= 2000:
+        return (
+            "Over 2,000 common medications are included. "
+            "You can also type any medication, vitamin, or supplement below."
+        )
     return (
-        f"{payload.get('source', 'RxTerms')} {payload.get('release', '')} "
-        f"({payload.get('count', 0):,} medication choices)"
+        "Common medications are included. "
+        "You can also type any medication, vitamin, or supplement below."
     )