feat: retrieval grounding, trial quality, and drug-name typo suggestions

Session of improvements to retrieval accuracy, clinical-trial matching, and
query robustness for the physician-facing tool.

Retrieval grounding & citation integrity:
- Grounding gate: suppress spurious semantic matches when a query's focus
entity is absent from the corpus (papers=0 → honest "no evidence"),
preventing citation-grafting hallucinations.
- Landscape-mention labeling: flag papers that name a compound only in
full-text pipeline tables (not the abstract) so the model labels such
citations instead of presenting them as primary studies.
- Keyword search + abstract-scoped grounding helpers in rag/retriever.py.
- Stricter synthesis prompt: inline citations, grounding rule, no training-
knowledge gap-filling.

Clinical trials:
- Include Expanded Access Programs (studyType:int exp); tag study_type /
is_expanded_access and surface "Expanded Access" as the phase label.
- Compound-specific trial matching: match only the queried compound/target
(never the KG-expanded galaxy), normalized so CNM-Au8/CNMAu8/cnm_au8 unify;
drop short-fragment false positives; rank available/recruiting first.

Drug-name typo tolerance (normalization/drug_vocab.py):
- Tiered canonicalization: variance (hyphen/space/case) and aliases resolve
automatically; true typos yield a transparent "did you mean?" suggestion
only — never a silent substitution (biomedical names are 1 edit apart, so
auto-correct could redirect onto a different drug).

Ingestion & cost:
- Prompt caching + parallel extraction batches (config/extractor).
- PMC idconv batching, PubMed retstart pagination, citation+recency reranking.
- BioLORD MPS device + capped section chunking in the indexer.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

README.md

@@ -66,7 +66,10 @@ uv run python scripts/build_index.py
 ### Launch
 
 ```bash
-# Web UI
+# Web UI (auto-reloads on file changes — use during development)
+uv run gradio app.py
+
+# Web UI (production / one-shot)
 uv run python app.py
 
 # CLI

agents/research_agent.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import json
+import re
 from collections.abc import Generator
 
 import anthropic
@@ -21,6 +22,7 @@ from config import (
 from graph import query as kg_query
 from llm import cached_system, cached_tools
 from logging_config import get_logger
+from normalization.drug_vocab import build_drug_vocab, suggest_drug_term
 from prompts import SYNTHESIS_SYSTEM
 from rag import retriever as rag_retriever
 from tools import RESEARCH_TOOLS
@@ -30,6 +32,20 @@ _logger = get_logger("agents.research_agent")
 # Loaded once at startup — ~80MB model, ~80ms/pair on CPU
 _cross_encoder = CrossEncoder(CROSS_ENCODER_MODEL)
 
+# Drug vocabulary is derived from the (startup-loaded) trials + graph; cache by identity
+# so it is built once per session rather than on every query.
+_DRUG_VOCAB_CACHE: dict[int, dict] = {}
+
+
+def _get_drug_vocab(trials: list[dict], graph: nx.DiGraph | None) -> dict:
+    key = id(trials)
+    vocab = _DRUG_VOCAB_CACHE.get(key)
+    if vocab is None:
+        vocab = build_drug_vocab(trials, graph)
+        _DRUG_VOCAB_CACHE.clear()  # session has one trials object; avoid unbounded growth
+        _DRUG_VOCAB_CACHE[key] = vocab
+    return vocab
+
 
 def stream_research_agent(
     client: anthropic.Anthropic,
@@ -51,15 +67,22 @@ def stream_research_agent(
     ]
     # Attach graph reference so _handle_search can use KG expansion
     _graph = graph
+    first_turn = True
 
     while True:
         stream_text = ""
 
+        # Force tool use on the first turn so Claude always searches before synthesizing.
+        # Unknown proper nouns (drug codes, gene IDs) would otherwise trigger a
+        # "I don't recognize X" response straight from training knowledge.
+        tool_choice: dict = {"type": "any"} if first_turn else {"type": "auto"}
+
         with client.messages.stream(
             model=SYNTHESIS_MODEL,
             max_tokens=4096,
             system=cached_system(SYNTHESIS_SYSTEM),
             tools=cached_tools(RESEARCH_TOOLS),
+            tool_choice=tool_choice,
             messages=messages,
         ) as stream:
             # Accumulate tool-use input JSON alongside streaming text
@@ -99,6 +122,8 @@ def stream_research_agent(
 
         messages.append({"role": "assistant", "content": final_msg.content})
 
+        first_turn = False
+
         if final_msg.stop_reason == "end_turn":
             yield ("done", stream_text)
             return
@@ -127,6 +152,53 @@ def stream_research_agent(
             return
 
 
+# Ubiquitous ALS disease descriptors — grounded across the whole corpus, so they
+# must never count as a query "focus" entity for the grounding gate.
+_GENERIC_EXACT = {"als", "mnd", "mnds", "ftd", "als/ftd", "disease", "neurodegeneration", "therapy", "treatment"}
+_GENERIC_SUBSTRINGS = ("amyotrophic", "lateral sclerosis", "motor neuron")
+
+
+def _is_generic_term(term: str) -> bool:
+    """True for disease-generic terms that are grounded everywhere (ALS, MND, etc.)."""
+    t = term.lower().strip()
+    if t in _GENERIC_EXACT:
+        return True
+    return any(sub in t for sub in _GENERIC_SUBSTRINGS)
+
+
+def _norm_alnum(s: str) -> str:
+    """Lowercase, alphanumeric-only form so 'CNM-Au8', 'CNMAu8', 'cnm_au8' all unify."""
+    return "".join(c for c in s.lower() if c.isalnum())
+
+
+# Trial status display order — available/recruiting first, closed/unavailable last.
+# Expanded Access uses AVAILABLE / TEMPORARILY_NOT_AVAILABLE / NO_LONGER_AVAILABLE.
+_TRIAL_STATUS_RANK = {
+    "AVAILABLE": 0,
+    "RECRUITING": 1,
+    "NOT_YET_RECRUITING": 2,
+    "ENROLLING_BY_INVITATION": 3,
+    "ACTIVE_NOT_RECRUITING": 4,
+    "TEMPORARILY_NOT_AVAILABLE": 5,
+    "COMPLETED": 6,
+    "SUSPENDED": 7,
+    "TERMINATED": 8,
+    "WITHDRAWN": 9,
+    "NO_LONGER_AVAILABLE": 10,
+}
+
+
+def _term_excerpt(document: str, terms: list[str], window: int = 600) -> str:
+    """Return a 600-char excerpt centred on the first keyword match, or the document start."""
+    doc_lower = document.lower()
+    for term in terms:
+        idx = doc_lower.find(term.lower())
+        if idx != -1:
+            start = max(0, idx - 200)
+            return document[start : start + window]
+    return document[:window]
+
+
 def _handle_search(
     tool_input: dict,
     collection: chromadb.Collection,
@@ -152,9 +224,52 @@ def _handle_search(
         collection, expanded_entities, n_results=RETRIEVAL_ENTITY_N
     )
 
+    # Step 3b: Keyword search — exact $contains match for specific named terms.
+    # Also extracts alphanumeric tokens from query_text (e.g. "SPG302", "C9orf72",
+    # "AMX0035") that Claude may not include in query_entities because it doesn't
+    # recognize them as known biological entities.
+    _entity_tokens = list({
+        tok for tok in re.findall(r'\b[A-Za-z]+\d+\w*|\b[A-Z]{2,}\d*\w*', query_text)
+        if len(tok) >= 3
+    })
+    keyword_terms = list(dict.fromkeys(query_entities + _entity_tokens))  # dedup, preserve order
+    keyword_results = rag_retriever.search_by_keyword(collection, keyword_terms)
+
+    # Grounding gate — determine whether the query's *specific* focus entities are
+    # genuinely present in the PAPER corpus. Semantic search always returns nearest
+    # neighbors regardless of relevance, so we check exact literal presence
+    # ($contains); otherwise Claude grafts real PMIDs onto topically-adjacent-but-
+    # unrelated papers. Two exclusions from the focus set:
+    #   - Ubiquitous disease descriptors (ALS / motor neuron disease) — grounded
+    #     everywhere, never the subject of the query.
+    #   - KG-node existence is deliberately NOT used as grounding: a compound can
+    #     have a graph node purely from trial data while having zero paper evidence
+    #     (e.g. SPG302). "In the corpus" means "written in a paper".
+    focus_terms = [t for t in keyword_terms if t.strip() and not _is_generic_term(t)]
+
+    # "Did you mean?" — for unrecognized focus terms, suggest the nearest known drug name
+    # (typo tolerance). SUGGESTION ONLY — the original term is still what gets searched, so a
+    # wrong suggestion can never silently redirect the query onto a different drug.
+    drug_vocab = _get_drug_vocab(trials, graph)
+    did_you_mean = {
+        t: s for t in focus_terms if (s := suggest_drug_term(t, drug_vocab))
+    }
+
+    grounded_terms: list[str] = []
+    ungrounded_terms: list[str] = []
+    for term in focus_terms:
+        if rag_retriever.is_grounded_in_corpus(collection, term):
+            grounded_terms.append(term)
+        else:
+            ungrounded_terms.append(term)
+
+    # If the query names specific entities and NONE are grounded in papers, the
+    # corpus holds no genuine evidence — Claude gets zero papers so it cannot graft.
+    evidence_ungrounded = bool(focus_terms) and not grounded_terms
+
     # Step 4: RRF merge → top 20 papers
     merged = rag_retriever.rrf_merge(
-        [semantic_results, entity_results], k=RRF_K, top_n=RRF_TOP_N
+        [semantic_results, entity_results, keyword_results], k=RRF_K, top_n=RRF_TOP_N
     )
 
     # Step 5: Cross-encoder rerank → top 15 papers
@@ -165,6 +280,29 @@ def _handle_search(
     # Step 6: Citation boost — final score = ce_score × log(citation_count + 2)
     top_papers = rag_retriever.apply_citation_boost(reranked)
 
+    # Apply the grounding gate: suppress spurious semantic matches when the query's
+    # focus entity is absent from the corpus. Trials are still returned below.
+    paper_pool = [] if evidence_ungrounded else top_papers
+
+    # Guarantee the papers that literally name a *landscape-only* focus compound are
+    # citable. When a compound appears only in full-text pipeline tables (no abstract
+    # anywhere — e.g. SPG302), the cross-encoder ranks those table chunks below generic
+    # semantic neighbors and they never reach the model, so it can neither cite nor
+    # label them. Inject their keyword-hits (capped). Well-grounded entities (C9orf72,
+    # tofersen) already surface primary papers via semantic/CE — skip injection for them.
+    landscape_only_terms = [
+        t for t in grounded_terms
+        if not rag_retriever.is_grounded_in_abstract(collection, t)
+    ]
+    if not evidence_ungrounded and landscape_only_terms:
+        present = {r["pmid"] for r in paper_pool}
+        focus_hits = rag_retriever.search_by_keyword(collection, landscape_only_terms)
+        for r in focus_hits[:5]:
+            if r["pmid"] not in present:
+                r.setdefault("score", r.get("similarity", 0.0))
+                paper_pool.append(r)
+                present.add(r["pmid"])
+
     _logger.info(
         "KG+RAG+CE search",
         extra={"data": {
@@ -172,49 +310,123 @@ def _handle_search(
             "expanded_entities": len(expanded_entities),
             "semantic_hits": len(semantic_results),
             "entity_hits": len(entity_results),
+            "keyword_hits": len(keyword_results),
             "rrf_merged": len(merged),
             "after_cross_encoder": len(top_papers),
+            "grounded_terms": grounded_terms,
+            "ungrounded_terms": ungrounded_terms,
+            "evidence_ungrounded": evidence_ungrounded,
+            "papers_returned": len(paper_pool),
             "kg_active": graph is not None,
         }},
     )
 
-    # Step 7: Trial matching — prefer KG-linked trials, fall back to text match
-    related_trials: list[dict] = []
-    if graph and query_entities:
-        related_trials = kg_query.find_trials_for_entities(graph, expanded_entities, max_trials=10)
-
-    if not related_trials:
-        # Exact NCT ID match first — handles "NCT06351592" style queries
-        nct_ids_in_query = {
-            w.upper() for w in query_text.split() if w.upper().startswith("NCT")
+    # Step 7: Trial matching — return ONLY trials genuinely about the queried compound
+    # or target, ranked available/recruiting first (EAPs, completed, and terminated all
+    # included). Match on the SPECIFIC query terms — never expanded_entities, whose KG
+    # expansion balloons to thousands of terms and floods results with unrelated ALS
+    # trials. Normalized (alphanumeric-only) matching unifies "CNM-Au8" / "CNMAu8" /
+    # "cnm_au8" across the query, trial interventions, and enriched target_entities.
+    specific_terms = [
+        t for t in dict.fromkeys(query_entities + focus_terms)
+        if t.strip() and not _is_generic_term(t)
+    ]
+    norm_terms = [n for n in (_norm_alnum(t) for t in specific_terms) if len(n) >= 3]
+    # Drop fragments that are substrings of a longer matched term — the query regex
+    # splits "CNM-Au8" into "CNM"/"Au8", whose short normalized forms ("cnm"/"au8")
+    # over-match unrelated trials. Keep only maximal terms (e.g. "cnmau8").
+    norm_terms = [n for n in norm_terms if not any(n != m and n in m for m in norm_terms)]
+    nct_ids_in_query = {w.upper() for w in query_text.split() if w.upper().startswith("NCT")}
+
+    matched: dict[str, dict] = {}
+    for trial in trials:
+        nct = trial.get("nct_id", "")
+        if not nct:
+            continue
+        iv_names = " ".join(iv.get("name", "") for iv in trial.get("interventions", []))
+        targets = " ".join(trial.get("target_entities", []))
+        hay = _norm_alnum(f"{trial.get('title', '')} {iv_names} {targets} {trial.get('summary', '')}")
+        if nct.upper() in nct_ids_in_query or any(nt in hay for nt in norm_terms):
+            matched[nct] = trial
+
+    ranked = sorted(matched.values(), key=lambda t: _TRIAL_STATUS_RANK.get(t.get("status", ""), 99))
+    related_trials = [
+        {
+            "nct_id": t.get("nct_id", ""),
+            "title": t.get("title", ""),
+            "phase": t.get("phase", ""),
+            "status": t.get("status", ""),
+            "study_type": t.get("study_type", ""),
+            "url": t.get("url", ""),
         }
-        trial_by_nct = {t.get("nct_id", "").upper(): t for t in trials}
-        for nct_id in nct_ids_in_query:
-            if nct_id in trial_by_nct:
-                t = trial_by_nct[nct_id]
-                related_trials.append({
-                    "nct_id": t.get("nct_id", ""),
-                    "title": t.get("title", ""),
-                    "phase": t.get("phase", ""),
-                    "status": t.get("status", ""),
-                    "url": t.get("url", ""),
-                })
+        for t in ranked[:10]
+    ]
 
-    if not related_trials and query_entities:
-        entities_lower = [e.lower() for e in expanded_entities]
-        for trial in trials:
-            iv_names = " ".join(iv.get("name", "") for iv in trial.get("interventions", []))
-            trial_text = f"{trial.get('title', '')} {iv_names}".lower()
-            if any(e in trial_text for e in entities_lower):
-                related_trials.append({
-                    "nct_id": trial.get("nct_id", ""),
-                    "title": trial.get("title", ""),
-                    "phase": trial.get("phase", ""),
-                    "status": trial.get("status", ""),
-                    "url": trial.get("url", ""),
-                })
-            if len(related_trials) >= 5:
-                break
+    # Context-aware grounding note steers the synthesis model away from hallucination.
+    if evidence_ungrounded:
+        _terms = ", ".join(ungrounded_terms) or "the queried entity"
+        grounding_note = (
+            f"NO paper evidence exists in this database for: {_terms}. "
+            "Do NOT synthesize a mechanism or any factual claim from training knowledge, and do "
+            "NOT cite any PMID. State explicitly that the paper database contains no evidence for "
+            f"{_terms}. Report ONLY the clinical trials listed below (if any) as the sole grounded "
+            "information."
+        )
+    elif not paper_pool:
+        grounding_note = (
+            "NO papers were retrieved. Do not synthesize from training knowledge — state that the "
+            "database does not contain evidence for this topic. Report only trials below (if any)."
+        )
+    else:
+        note = f"{len(paper_pool)} papers retrieved. Cite a PMID only for claims stated in that paper's excerpt below."
+        if ungrounded_terms:
+            note += (
+                f" IMPORTANT: the database has NO evidence for: {', '.join(ungrounded_terms)}. "
+                "Say so explicitly and never attach a PMID to any claim about those terms."
+            )
+        note += (
+            " Papers marked evidence_tier='landscape_mention' name a compound only in their full "
+            "text (e.g. a drug-pipeline table), not their abstract — when citing such a paper for "
+            "that compound, label the citation as a full-text/pipeline-table mention, not a primary study."
+        )
+        grounding_note = note
+
+    # Typo suggestions (never substituted into the search). Surface as "did you mean?".
+    if did_you_mean:
+        hints = "; ".join(f"'{k}' → '{v}'" for k, v in did_you_mean.items())
+        grounding_note += (
+            f" POSSIBLE TYPOS (unrecognized query terms with a near match in the database): {hints}. "
+            "If a suggestion looks right, tell the physician there was no exact match and ask whether "
+            "they meant the suggested name, inviting them to re-query with it. Do NOT assume the "
+            "suggestion is correct and do NOT search it yourself."
+        )
+
+    # Evidence tier — for each paper, flag focus terms (drug codes) that appear only in its
+    # full text, not its abstract. A compound named only in a full-text pipeline/landscape
+    # table means the paper is not a primary source for it; the synthesis model labels such
+    # citations accordingly. Checks the paper's full concatenated text (all chunks), because
+    # the retrieved representative chunk often is not the one holding the compound name.
+    texts_by_pmid = rag_retriever.paper_texts_for_pmids(
+        collection, [r["pmid"] for r in paper_pool]
+    )
+    # Only compounds that are landscape-only across the WHOLE corpus (absent from every
+    # abstract, e.g. SPG302) can be reliably flagged from an abstract-vs-fulltext check.
+    # A common gene like C9orf72 is discussed in many paper bodies without appearing in
+    # their abstract — flagging those would wrongly demote primary studies, so restrict
+    # the check to landscape_only_terms.
+    fulltext_only_by_pmid: dict[str, list[str]] = {}
+    for r in paper_pool:
+        pmid = r["pmid"]
+        texts = texts_by_pmid.get(pmid, {"abstract": "", "full": ""})
+        fulltext_only_by_pmid[pmid] = [
+            t for t in landscape_only_terms
+            if rag_retriever.term_matches_text(texts["full"], t)
+            and not rag_retriever.term_matches_text(texts["abstract"], t)
+        ]
+
+    _landscape = {pmid: terms for pmid, terms in fulltext_only_by_pmid.items() if terms}
+    if _landscape:
+        _logger.info("landscape-mention citations flagged", extra={"data": {"papers": _landscape}})
 
     return {
         "papers": [
@@ -225,14 +437,19 @@ def _handle_search(
                 "doi": r["doi"],
                 "citation_count": r["citation_count"],
                 "section": r["section"],
-                "excerpt": r["document"][:600],
+                "excerpt": _term_excerpt(r["document"], keyword_terms),
                 "score": round(r["score"], 3),
+                "fulltext_only_mentions": fulltext_only_by_pmid.get(r["pmid"], []),
+                "evidence_tier": "landscape_mention" if fulltext_only_by_pmid.get(r["pmid"]) else "primary",
             }
-            for r in top_papers
+            for r in paper_pool
         ],
         "query_entities": query_entities,
         "expanded_entities": expanded_entities,
+        "ungrounded_terms": ungrounded_terms,
+        "did_you_mean": did_you_mean,
         "trials": related_trials,
-        "evidence_count": len(top_papers),
+        "evidence_count": len(paper_pool),
         "kg_expansion_active": graph is not None,
+        "grounding_note": grounding_note,
     }

config.py

@@ -33,21 +33,18 @@ PUBMED_BASE_QUERY = (
     '"amyotrophic lateral sclerosis"[MeSH Major Topic] '
     "AND hasabstract[text]"
 )
-PUBMED_DEFAULT_QUERY = (
-    '"amyotrophic lateral sclerosis"[MeSH Major Topic] '
-    'AND ("2018"[PDAT]:"2024"[PDAT]) '
-    "AND hasabstract[text]"
-)
+PUBMED_DEFAULT_QUERY = PUBMED_BASE_QUERY  # no date cap — fetch all 19k+ ALS papers
 PUBMED_REFRESH_QUERY_TEMPLATE = (
     '"amyotrophic lateral sclerosis"[MeSH Major Topic] '
     'AND ("{since_date}"[PDAT]:"3000"[PDAT]) '
     "AND hasabstract[text]"
 )
-PUBMED_DEFAULT_MAX = 500
+PUBMED_DEFAULT_MAX = 20000
 PUBMED_BATCH_SIZE = 200  # PMIDs per Entrez efetch call
 
 # Entity extraction
-EXTRACTION_BATCH_SIZE = 10  # papers per Claude call
+EXTRACTION_BATCH_SIZE = 20  # papers per Claude call
+EXTRACTION_WORKERS = 8      # parallel Claude calls (Haiku limit: 1000 RPM on paid tier)
 
 # RAG — retrieval counts per stage
 CHROMA_N_RESULTS = 10          # legacy default (kept for backward compat)

extraction/extractor.py

@@ -1,12 +1,15 @@
 """
-Claude Sonnet entity extractor.
-Batches 10 papers per API call; resumable via .progress.json.
+Claude Haiku entity extractor.
+Batches 20 papers per API call; resumable via .progress.json.
 Uses full_text when available, otherwise abstract.
+Prompt caching on system + tools reduces per-call cost ~40%.
 """
 from __future__ import annotations
 
 import json
+import threading
 import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
 import anthropic
@@ -17,6 +20,7 @@ from config import (
     EXTRACTION_BATCH_SIZE,
     EXTRACTION_MODEL,
     EXTRACTION_PROGRESS_PATH,
+    EXTRACTION_WORKERS,
     PAPERS_PATH,
 )
 from extraction.normalizer import CanonicalRegistry, guess_entity_type, normalize_entity
@@ -44,7 +48,11 @@ def extract_all(
     progress_path: Path = EXTRACTION_PROGRESS_PATH,
     client: anthropic.Anthropic | None = None,
 ) -> list[PaperExtractionResult]:
-    """Extract entities from all papers. Skips already-processed PMIDs."""
+    """Extract entities from all papers. Skips already-processed PMIDs.
+
+    Runs EXTRACTION_WORKERS batches in parallel. A lock serializes file writes
+    and progress saves so threads don't corrupt each other.
+    """
     if client is None:
         client = anthropic.Anthropic()
 
@@ -60,7 +68,9 @@ def extract_all(
     registry = CanonicalRegistry()
     entities_path.parent.mkdir(parents=True, exist_ok=True)
 
+    batches = [pending[i : i + EXTRACTION_BATCH_SIZE] for i in range(0, len(pending), EXTRACTION_BATCH_SIZE)]
     results: list[PaperExtractionResult] = []
+    write_lock = threading.Lock()
 
     with (
         open(entities_path, "a", encoding="utf-8") as out_f,
@@ -73,22 +83,22 @@ def extract_all(
     ):
         task = progress.add_task("Extracting entities", total=len(pending))
 
-        for i in range(0, len(pending), EXTRACTION_BATCH_SIZE):
-            batch = pending[i : i + EXTRACTION_BATCH_SIZE]
-            batch_results = _extract_batch(client, batch, registry)
-
-            for result in batch_results:
-                out_f.write(json.dumps(result.to_dict()) + "\n")
-                done_pmids.add(result.pmid)
-                results.append(result)
-
-            _save_progress(progress_path, done_pmids)
-            registry.save()
-            progress.advance(task, len(batch))
-
-            # Respect rate limits between batches
-            if i + EXTRACTION_BATCH_SIZE < len(pending):
-                time.sleep(1.0)
+        def _process_batch(batch: list[ALSPaper]) -> list[PaperExtractionResult]:
+            return _extract_batch(client, batch, registry)
+
+        with ThreadPoolExecutor(max_workers=EXTRACTION_WORKERS) as pool:
+            futures = {pool.submit(_process_batch, b): b for b in batches}
+            for future in as_completed(futures):
+                batch_results = future.result()
+                with write_lock:
+                    for result in batch_results:
+                        out_f.write(json.dumps(result.to_dict()) + "\n")
+                        done_pmids.add(result.pmid)
+                        results.append(result)
+                    out_f.flush()
+                    _save_progress(progress_path, done_pmids)
+                    registry.save()
+                    progress.advance(task, len(futures[future]))
 
     return results
 
@@ -160,29 +170,38 @@ def _extract_batch(
 
 
 def _call_claude(client: anthropic.Anthropic, batch: list[ALSPaper]) -> list:
-    """Raw Claude call — returns response.content blocks."""
-    try:
+    """Raw Claude call — returns response.content blocks.
+
+    Prompt caching: system and tools are static across all calls; adding
+    cache_control to the last tool + system block caches the entire prefix
+    (tools render before system in the API token order). Cache reads cost
+    ~10% of normal input price, halving the effective per-call overhead.
+    """
+    # Cache the static system+tools prefix across batch calls
+    cached_system = [{"type": "text", "text": _EXTRACTION_SYSTEM, "cache_control": {"type": "ephemeral"}}]
+    cached_tools = list(EXTRACTION_TOOLS)
+    if cached_tools:
+        last = dict(cached_tools[-1])
+        last["cache_control"] = {"type": "ephemeral"}
+        cached_tools[-1] = last
+
+    def _request() -> list:
         response = client.messages.create(
             model=EXTRACTION_MODEL,
-            max_tokens=4096,
-            system=_EXTRACTION_SYSTEM,
-            tools=EXTRACTION_TOOLS,
+            max_tokens=8192,
+            system=cached_system,
+            tools=cached_tools,
             tool_choice={"type": "any"},
             messages=[{"role": "user", "content": _format_batch(batch)}],
         )
         return response.content
+
+    try:
+        return _request()
     except anthropic.RateLimitError:
         _logger.warning("Rate limited — sleeping 30s")
         time.sleep(30)
-        response = client.messages.create(
-            model=EXTRACTION_MODEL,
-            max_tokens=4096,
-            system=_EXTRACTION_SYSTEM,
-            tools=EXTRACTION_TOOLS,
-            tool_choice={"type": "any"},
-            messages=[{"role": "user", "content": _format_batch(batch)}],
-        )
-        return response.content
+        return _request()
 
 
 def _format_batch(batch: list[ALSPaper]) -> str:
@@ -192,8 +211,8 @@ def _format_batch(batch: list[ALSPaper]) -> str:
     ]
     for paper in batch:
         text = paper.full_text if paper.full_text else paper.abstract
-        # Cap at 3000 chars to stay within token budget for a 10-paper batch
-        excerpt = text[:3000] if text else paper.abstract[:1000]
+        # Cap at 2000 chars — 20-paper batches at ~500 tokens each stay well under 8192 output limit
+        excerpt = text[:2000] if text else paper.abstract[:1000]
         parts.append(
             f"--- PMID:{paper.pmid} ---\n"
             f"Title: {paper.title}\n\n"
@@ -209,6 +228,8 @@ def _parse_entities(
 ) -> list[ExtractedEntity]:
     entities = []
     for item in raw:
+        if not isinstance(item, dict):
+            continue
         name = item.get("name", "").strip()
         entity_type = item.get("type", "").strip()
         if not name or not entity_type:
@@ -233,6 +254,8 @@ def _parse_relationships(
 ) -> list[EntityRelationship]:
     rels = []
     for item in raw:
+        if not isinstance(item, dict):
+            continue
         source_name = item.get("source", "").strip()
         target_name = item.get("target", "").strip()
         rel_type = item.get("type", "").strip()

ingestion/clinicaltrials.py

@@ -28,16 +28,19 @@ Call extract_trial_targets once per trial. Return an empty targets list only whe
 
 
 def fetch_als_trials(
-    status: str | list[str] = ("RECRUITING", "NOT_YET_RECRUITING", "ACTIVE_NOT_RECRUITING"),
     client: "anthropic.Anthropic | None" = None,
 ) -> list[dict]:
-    """Fetch ALS interventional trials. Returns flat dicts ready for JSONL serialization."""
-    status_filter = ",".join(status) if isinstance(status, (list, tuple)) else status
-
+    """Fetch all ALS interventional + expanded-access studies, regardless of status.
+
+    No status filter — completed, terminated, and withdrawn trials are as
+    clinically important as active ones (negative results inform research).
+    `studyType:int exp` includes both interventional trials AND Expanded Access
+    Programs (EAP / compassionate use, e.g. NCT05281484), which physicians need for
+    off-trial access options. Status filtering is left to query time.
+    """
     params: dict[str, str | int] = {
         "query.cond": "Amyotrophic Lateral Sclerosis",
-        "filter.overallStatus": status_filter,
-        "aggFilters": "studyType:int",
+        "aggFilters": "studyType:int exp",
         "pageSize": 1000,
         "format": "json",
     }
@@ -91,11 +94,17 @@ def _flatten_trial(study: dict) -> dict:
         for iv in arms_mod.get("interventions", [])
     ]
 
+    study_type = design_mod.get("studyType", "")
+    is_eap = study_type == "EXPANDED_ACCESS"
+
     return {
         "nct_id": nct_id,
         "title": id_mod.get("briefTitle", ""),
-        "phase": ", ".join(design_mod.get("phases", [])) or "N/A",
+        # Expanded Access has no trial phase — surface it as the phase label instead
+        "phase": "Expanded Access" if is_eap else (", ".join(design_mod.get("phases", [])) or "N/A"),
         "status": status_mod.get("overallStatus", ""),
+        "study_type": study_type,
+        "is_expanded_access": is_eap,
         "sponsor": sponsor_mod.get("leadSponsor", {}).get("name", ""),
         "summary": desc_mod.get("briefSummary", ""),
         "interventions": interventions,

ingestion/pmc.py

@@ -27,19 +27,29 @@ def _sleep() -> None:
     time.sleep(0.1 if os.getenv("NCBI_API_KEY") else 0.4)
 
 
+_IDCONV_URL = "https://www.ncbi.nlm.nih.gov/pmc/utils/idconv/v1.0/"
+_IDCONV_BATCH = 200
+
+
 def get_pmcids(pmids: list[str]) -> dict[str, str]:
     """
     Map PubMed IDs to PMC IDs for papers with Open Access full text.
-    Sends one PMID at a time — batch elink merges all results into one
-    LinkSet with no per-ID mapping, making it unusable for this purpose.
+    Uses the NCBI ID Converter API (idconv) which accepts batches of 200 PMIDs
+    and returns a proper PMID→PMCID mapping — dramatically faster than one
+    elink call per PMID.
     Returns {pmid: pmcid}.
     """
-    _configure_entrez()
+    import urllib.request
+    import urllib.parse
+
     if not pmids:
         return {}
 
     from rich.progress import Progress, SpinnerColumn, BarColumn, TaskProgressColumn, TimeRemainingColumn, TextColumn
+
+    email = os.environ.get("ENTREZ_EMAIL", "")
     result: dict[str, str] = {}
+    batches = [pmids[i : i + _IDCONV_BATCH] for i in range(0, len(pmids), _IDCONV_BATCH)]
 
     with Progress(
         SpinnerColumn(),
@@ -48,31 +58,36 @@ def get_pmcids(pmids: list[str]) -> dict[str, str]:
         TaskProgressColumn(),
         TimeRemainingColumn(),
     ) as progress:
-        task = progress.add_task("Looking up PMC IDs...", total=len(pmids))
-
-        for pmid in pmids:
+        task = progress.add_task("Looking up PMC IDs...", total=len(batches))
+
+        for batch in batches:
+            params = urllib.parse.urlencode({
+                "ids": ",".join(batch),
+                "format": "json",
+                "email": email,
+            })
+            url = f"{_IDCONV_URL}?{params}"
             for attempt in range(3):
                 try:
-                    handle = Entrez.elink(dbfrom="pubmed", db="pmc", id=pmid)
-                    link_sets = Entrez.read(handle)
-                    handle.close()
+                    with urllib.request.urlopen(url, timeout=30) as resp:
+                        import json as _json
+                        data = _json.loads(resp.read())
                     break
                 except Exception as exc:
                     if attempt == 2:
-                        _logger.debug(f"elink failed for PMID {pmid}: {exc}")
-                        link_sets = []
+                        _logger.warning(f"idconv batch failed: {exc}")
+                        data = {}
                         break
                     time.sleep(2 ** attempt)
 
-            for ls in link_sets:
-                for db_link in ls.get("LinkSetDb", []):
-                    if db_link.get("DbTo") == "pmc":
-                        links = db_link.get("Link", [])
-                        if links:
-                            result[pmid] = str(links[0]["Id"])
-                        break
+            for record in data.get("records", []):
+                pmid = record.get("pmid")
+                pmcid = record.get("pmcid")
+                # pmid comes back as int from the API; pmcid is like "PMC1234567"
+                if pmid and pmcid and pmcid.startswith("PMC"):
+                    result[str(pmid)] = pmcid[3:]
 
-            _sleep()
+            time.sleep(0.4)
             progress.advance(task)
 
     _logger.info("PMC ID lookup", extra={"data": {"pmids": len(pmids), "found": len(result)}})
@@ -112,19 +127,22 @@ def _parse_jats_xml(xml_data: bytes) -> str | None:
         return None
 
     sections: list[str] = []
-    for sec in body.findall(".//sec"):
-        # Skip nested sections — only top-level sec elements under body
-        if sec in body:
-            title_el = sec.find("title")
-            title = (title_el.text or "Section").strip() if title_el is not None else "Section"
-
-            paragraphs: list[str] = []
-            for p in sec.findall("p"):
-                text = "".join(p.itertext()).strip()
-                if text:
-                    paragraphs.append(text)
-
-            if paragraphs:
-                sections.append(f"[{title}]\n" + "\n".join(paragraphs))
+
+    # Try structured sections first (standard JATS)
+    top_secs = [sec for sec in body.findall(".//sec") if sec in body]
+    for sec in top_secs:
+        title_el = sec.find("title")
+        title = (title_el.text or "Section").strip() if title_el is not None else "Section"
+        paragraphs = ["".join(p.itertext()).strip() for p in sec.findall(".//p")]
+        paragraphs = [t for t in paragraphs if t]
+        if paragraphs:
+            sections.append(f"[{title}]\n" + "\n".join(paragraphs))
+
+    # Fall back to bare paragraphs when there are no top-level sec elements
+    if not sections:
+        paragraphs = ["".join(p.itertext()).strip() for p in body.findall(".//p")]
+        paragraphs = [t for t in paragraphs if t]
+        if paragraphs:
+            sections.append("[Body]\n" + "\n".join(paragraphs))
 
     return "\n\n".join(sections) if sections else None

ingestion/pubmed.py

@@ -28,14 +28,39 @@ def _sleep() -> None:
     time.sleep(0.1 if os.getenv("NCBI_API_KEY") else 0.4)
 
 
+_ESEARCH_PAGE_SIZE = 9999  # NCBI hard cap per esearch call
+
+
 def search_pmids(query: str, max_results: int = 500) -> list[str]:
-    """Search PubMed with a query string and return a list of PMIDs."""
+    """Search PubMed with a query string and return a list of PMIDs.
+
+    Pages through esearch results in chunks of 9,999 (NCBI's per-call cap)
+    until max_results or the total result count is reached.
+    """
     _configure_entrez()
-    handle = Entrez.esearch(db="pubmed", term=query, retmax=max_results)
-    record = Entrez.read(handle)
-    handle.close()
-    pmids = list(record["IdList"])
-    _logger.info("PubMed esearch", extra={"data": {"count": len(pmids), "query": query[:80]}})
+    pmids: list[str] = []
+    retstart = 0
+    total: int | None = None
+
+    while True:
+        want = min(_ESEARCH_PAGE_SIZE, max_results - len(pmids))
+        handle = Entrez.esearch(db="pubmed", term=query, retmax=want, retstart=retstart)
+        record = Entrez.read(handle)
+        handle.close()
+
+        if total is None:
+            total = int(record["Count"])
+
+        page = list(record["IdList"])
+        pmids.extend(page)
+
+        if not page or len(pmids) >= max_results or len(pmids) >= total:
+            break
+
+        retstart += len(page)
+        _sleep()
+
+    _logger.info("PubMed esearch", extra={"data": {"count": len(pmids), "total": total, "query": query[:80]}})
     return pmids
 
 

normalization/drug_vocab.py

@@ -0,0 +1,114 @@
+"""
+Query-time drug-name canonicalization: variance + typo auto-fix.
+
+Behavior:
+  1. Variance (hyphen/space/case) — auto-handled downstream by normalized matching, e.g.
+     'Prime-C'/'PrimeC'/'prime c' all match 'primec'. No note.
+  2. Alias (brand↔generic, code↔name) — resolved via extraction.normalizer tables. No note.
+  3. Typo — NOT auto-substituted. A conservative fuzzy match (rapidfuzz) yields a transparent
+     "did you mean X?" SUGGESTION only; the original term is still what gets searched.
+
+Why typos are suggested, not silently fixed: biomedical names are adversarially dense. Empirically
+'biib068'→'BIIB078' (a DIFFERENT drug) scores 85.7, higher than the genuine typo 'primce'→'primec'
+at 83.3 — so no score threshold can auto-correct the real typo without also silently mapping a
+query onto the wrong drug. For a physician tool that is unacceptable, so tier 3 never changes the
+searched term; it only surfaces a suggestion the physician can choose to act on.
+"""
+from __future__ import annotations
+
+from rapidfuzz import fuzz, process
+
+from extraction.normalizer import _COMPOUND_ALIASES, _GENE_ALIASES
+from logging_config import get_logger
+
+_logger = get_logger("normalization.drug_vocab")
+
+# Fuzzy-SUGGESTION guards (calibrated: primce/primec ≈ 83; word-drug typos ≈ 87–94).
+# Suggestions never change the searched term, so no ambiguity gap is needed — the physician
+# sees the candidate and decides. Length floor still skips short gene codes (SOD1, NEK1, FUS).
+_FUZZY_MIN_LEN = 6
+_FUZZY_MIN_SCORE = 82.0
+
+
+def _norm(s: str) -> str:
+    """Lowercase, alphanumeric-only form so 'Prime-C'/'PrimeC'/'prime c' unify to 'primec'."""
+    return "".join(c for c in s.lower() if c.isalnum())
+
+
+def build_drug_vocab(trials: list[dict], graph=None) -> dict[str, object]:
+    """
+    Build the query-time drug vocabulary as {"exact": frozenset, "fuzzy": {norm: display}}.
+
+    - `exact` (tier 1/2 membership): every normalized known name — alias forms, trial
+      intervention names + target_entities, and KG Compound names. Broad on purpose so a real
+      drug/intervention always resolves exactly and is NEVER sent to fuzzy correction.
+    - `fuzzy` (tier 3 candidates): clean CANONICAL drug names only — alias-table values and KG
+      Compound display names. Excludes messy intervention strings ("riluzole 50 mg tablet")
+      whose near-duplicates would otherwise act as false ambiguity competitors and block valid
+      corrections. Built once at startup and passed into the search handler.
+    """
+    exact: set[str] = set()
+    fuzzy: dict[str, str] = {}
+
+    def _add_exact(name: str) -> None:
+        n = _norm(name)
+        if len(n) >= 3:
+            exact.add(n)
+
+    def _add_fuzzy(name: str) -> None:
+        n = _norm(name)
+        if len(n) >= 3:
+            fuzzy.setdefault(n, name)
+            exact.add(n)
+
+    # Alias tables — canonical values are clean drug names (fuzzy), surface forms exact-only.
+    for alias, canonical in {**_COMPOUND_ALIASES, **_GENE_ALIASES}.items():
+        _add_exact(alias)
+        _add_fuzzy(canonical)
+
+    # KG Compound node display names — clean canonical drug names (fuzzy candidates).
+    if graph is not None:
+        for _, data in graph.nodes(data=True):
+            if data.get("type") == "Compound":
+                _add_fuzzy(data.get("display_name", ""))
+
+    # Trial interventions + enriched targets — exact-match coverage only (often verbose).
+    for t in trials or []:
+        for iv in t.get("interventions", []):
+            _add_exact(iv.get("name", ""))
+        for tgt in t.get("target_entities", []):
+            _add_exact(tgt)
+
+    _logger.info("drug vocabulary built", extra={"data": {"exact": len(exact), "fuzzy": len(fuzzy)}})
+    return {"exact": frozenset(exact), "fuzzy": fuzzy}
+
+
+def suggest_drug_term(term: str, vocab: dict[str, object]) -> str | None:
+    """
+    Return a "did you mean 'X'?" suggestion for an unrecognized query drug term, or None.
+
+    NEVER substitutes — the caller keeps searching the original term. Suggestion fires only for
+    unknown terms (absent from the exact vocabulary), of sufficient length, whose closest clean
+    canonical drug name scores above the floor. Safe by construction: a wrong suggestion cannot
+    silently redirect the search onto a different drug; the physician decides.
+    """
+    if not term or not term.strip():
+        return None
+    exact: frozenset = vocab.get("exact", frozenset())  # type: ignore[assignment]
+    fuzzy: dict[str, str] = vocab.get("fuzzy", {})       # type: ignore[assignment]
+
+    n = _norm(term)
+    if len(n) < _FUZZY_MIN_LEN or n in exact or not fuzzy:
+        return None
+
+    match = process.extractOne(n, list(fuzzy.keys()), scorer=fuzz.ratio)
+    if not match:
+        return None
+    best_key, best_score, _ = match
+    if best_score >= _FUZZY_MIN_SCORE and _norm(fuzzy[best_key]) != n:
+        resolved = fuzzy[best_key]
+        _logger.info("drug typo suggestion", extra={"data": {
+            "query_term": term, "suggested": resolved, "score": round(best_score, 1),
+        }})
+        return resolved
+    return None

prompts.py

@@ -32,6 +32,7 @@ When answering a physician's question, structure your response as follows:
 
 ## Key Mechanisms
 2–3 bullet points summarizing the core biological mechanisms relevant to the query.
+End every bullet with the inline PMID(s) that support it, e.g. "(PMID: 33259633)".
 
 ## Entities Involved
 Brief descriptions of the key genes, proteins, compounds, or pathways involved,
@@ -53,8 +54,13 @@ Any relevant ALS clinical trials linked to the topic, with NCT ID and status.
 Not a substitute for clinical judgment.*
 
 Guidelines:
-- Be precise and cite PMIDs for every factual claim where available
-- Acknowledge uncertainty where evidence is limited or conflicting
+- Begin directly with the structured response — no preamble, no "let me search", no narration of your reasoning steps
+- GROUNDING RULE (non-negotiable): Every factual claim must be directly supported by text in the retrieved excerpt for the PMID you cite. Before citing a PMID, verify the claim actually appears in that paper's excerpt. NEVER cite a PMID because it is topically adjacent — a citation asserts that specific paper supports that specific claim.
+- Do NOT use training knowledge to fill gaps. If a retrieved excerpt does not state it, you cannot assert it with a citation.
+- Honor the `grounding_note` in the search result. If it says the database has no evidence for an entity, state that plainly and do not describe its mechanism or cite any PMID for it — even if you recall information from training. Report only the clinical trials returned, if any.
+- EVIDENCE TIER: Each retrieved paper carries `evidence_tier` and `fulltext_only_mentions`. When you cite a paper for a compound listed in its `fulltext_only_mentions` (i.e. the paper mentions it only in its full text, e.g. a drug-pipeline table, not its abstract), you MUST label that citation, e.g. "(PMID: 40858858 — named in a drug-pipeline table, not a primary study of SPG302)". Never present an `evidence_tier` of "landscape_mention" as a primary mechanistic source.
+- If retrieved evidence is insufficient, say exactly: "The papers retrieved from this database do not contain information about [topic]."
+- DID-YOU-MEAN: If `did_you_mean` maps a query term to a suggested drug name, the term was not recognized. Tell the physician there was no exact match and ask whether they meant the suggested name (e.g. "No exact match for 'primce' — did you mean 'PrimeC'? Re-run with that name to see its trials and evidence."). Never assume the suggestion is correct or fabricate results for it.
 - Use clinical language appropriate for a physician audience
 - If a query falls outside ALS research, note that and answer only from ALS context
 """

pyproject.toml

@@ -15,6 +15,7 @@ dependencies = [
     "rich>=13.0.0",
     "sentence-transformers>=3.0.0",
     "openai>=2.44.0",
+    "rapidfuzz>=3.14.5",
 ]
 
 [project.optional-dependencies]

rag/indexer.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
+import torch
 import chromadb
 from chromadb.utils.embedding_functions import SentenceTransformerEmbeddingFunction
+from rich.progress import BarColumn, MofNCompleteColumn, Progress, TextColumn, TimeElapsedColumn
 
 from config import CHROMA_COLLECTION, CHROMA_DIR, PAPERS_PATH
 from logging_config import get_logger
@@ -13,9 +15,12 @@ from models import ALSPaper
 
 _logger = get_logger("rag.indexer")
 
+# Use MPS on Apple Silicon, CUDA on NVIDIA, otherwise CPU.
+_DEVICE = "mps" if torch.backends.mps.is_available() else ("cuda" if torch.cuda.is_available() else "cpu")
+
 # BioLORD-2023-C: anchored to UMLS/SNOMED CT/MeSH ontologies — natively understands
 # biomedical synonyms (TARDBP = TDP-43, SOD1 = superoxide dismutase) and clinical phrasing.
-_EMBED_FN = SentenceTransformerEmbeddingFunction(model_name="FremyCompany/BioLORD-2023-C")
+_EMBED_FN = SentenceTransformerEmbeddingFunction(model_name="FremyCompany/BioLORD-2023-C", device=_DEVICE)
 
 
 def _chunk_paper(paper: ALSPaper) -> list[dict]:
@@ -58,8 +63,16 @@ def _chunk_paper(paper: ALSPaper) -> list[dict]:
             if body:
                 sections.append((current_title, body))
 
+        # Prioritise high-value sections; cap at 6 total to keep index lean.
+        # With 500 papers the cross-encoder only sees 20 candidates anyway —
+        # 50+ chunks per paper adds noise without improving recall.
+        _PRIORITY = {"abstract", "introduction", "results", "discussion", "conclusion", "methods"}
+        priority = [s for s in sections if s[0].lower() in _PRIORITY]
+        others = [s for s in sections if s[0].lower() not in _PRIORITY]
+        selected = (priority + others)[:6]
+
         chunks = []
-        for i, (section_title, section_text) in enumerate(sections):
+        for i, (section_title, section_text) in enumerate(selected):
             doc = f"{paper.title}\n[{section_title}]\n{section_text}"
             chunks.append({
                 "id": f"{paper.pmid}_s{i}",
@@ -127,13 +140,22 @@ def build_collection(
     _logger.info(f"Indexing {len(new_chunks)} new chunks from {len(papers)} papers")
 
     batch_size = 100
-    for i in range(0, len(new_chunks), batch_size):
-        batch = new_chunks[i : i + batch_size]
-        collection.add(
-            ids=[c["id"] for c in batch],
-            documents=[c["document"] for c in batch],
-            metadatas=[c["metadata"] for c in batch],
-        )
+    batches = [new_chunks[i : i + batch_size] for i in range(0, len(new_chunks), batch_size)]
+
+    with Progress(
+        TextColumn("[cyan]Embedding chunks[/cyan]"),
+        BarColumn(),
+        MofNCompleteColumn(),
+        TimeElapsedColumn(),
+    ) as progress:
+        task = progress.add_task("", total=len(new_chunks))
+        for batch in batches:
+            collection.add(
+                ids=[c["id"] for c in batch],
+                documents=[c["document"] for c in batch],
+                metadatas=[c["metadata"] for c in batch],
+            )
+            progress.advance(task, len(batch))
 
     _logger.info(f"Collection '{collection_name}': {collection.count()} total chunks")
     return collection

rag/retriever.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import math
+import re
 
 import chromadb
 
@@ -72,6 +73,154 @@ def search_by_entities(
     return merged[:n_results]
 
 
+def _term_variants(term: str) -> list[str]:
+    """
+    Generate letter/digit boundary variants of a compound identifier so that
+    "SPG302", "SPG 302", and "SPG-302" all resolve to the same papers.
+    "SPG302" → ["SPG302", "SPG 302", "SPG-302"]
+    """
+    # Collapse any existing space/hyphen at letter–digit boundaries → canonical form
+    canonical = re.sub(r'(?<=[A-Za-z])[\s\-](?=\d)|(?<=\d)[\s\-](?=[A-Za-z])', '', term)
+    spaced = re.sub(r'([A-Za-z])(\d)', r'\1 \2', canonical)
+    hyphenated = re.sub(r'([A-Za-z])(\d)', r'\1-\2', canonical)
+    return list(dict.fromkeys([term, canonical, spaced, hyphenated]))
+
+
+def term_matches_text(text: str, term: str) -> bool:
+    """True if any spacing/hyphen variant of `term` appears in `text` (case-insensitive)."""
+    if not text or not term.strip():
+        return False
+    low = text.lower()
+    return any(v.lower() in low for v in _term_variants(term) if v.strip())
+
+
+def paper_texts_for_pmids(
+    collection: chromadb.Collection,
+    pmids: list[str],
+) -> dict[str, dict[str, str]]:
+    """
+    Fetch ALL chunks for each PMID in one call and return, per PMID:
+      {"abstract": <chunk_index 0 doc>, "full": <all chunk docs concatenated>}.
+    Used to distinguish "the paper is actually about this compound" (present in the
+    abstract) from an incidental full-text-only mention (present somewhere in the
+    body, e.g. a drug-pipeline table, but not the abstract). Fetching every chunk is
+    required because the retrieved representative chunk is often NOT the one holding
+    the compound name.
+    """
+    pmids = [p for p in dict.fromkeys(pmids) if p]
+    if not pmids:
+        return {}
+    try:
+        res = collection.get(
+            where={"pmid": {"$in": pmids}},
+            include=["documents", "metadatas"],
+        )
+    except Exception:
+        return {}
+    out: dict[str, dict[str, str]] = {p: {"abstract": "", "full": ""} for p in pmids}
+    parts: dict[str, list[str]] = {p: [] for p in pmids}
+    for meta, doc in zip(res.get("metadatas", []), res.get("documents", [])):
+        pmid = meta.get("pmid", "")
+        if pmid not in out:
+            continue
+        doc = doc or ""
+        parts[pmid].append(doc)
+        if meta.get("chunk_index") == 0:
+            out[pmid]["abstract"] = doc
+    for pmid in out:
+        out[pmid]["full"] = "\n".join(parts[pmid])
+    return out
+
+
+def is_grounded_in_abstract(collection: chromadb.Collection, term: str) -> bool:
+    """
+    True if any variant of `term` appears in an abstract chunk (chunk_index == 0).
+    Signals that at least one paper is genuinely *about* the term, as opposed to
+    only naming it in a full-text pipeline/landscape table.
+    """
+    if not term.strip() or collection.count() == 0:
+        return False
+    for variant in _term_variants(term):
+        if not variant.strip():
+            continue
+        try:
+            raw = collection.get(
+                where={"chunk_index": {"$eq": 0}},
+                where_document={"$contains": variant},
+                limit=1,
+                include=["metadatas"],
+            )
+        except Exception:
+            continue
+        if raw.get("ids"):
+            return True
+    return False
+
+
+def is_grounded_in_corpus(collection: chromadb.Collection, term: str) -> bool:
+    """
+    True if any spacing/hyphen variant of `term` appears literally in a paper
+    (ChromaDB $contains). This is exact-substring presence — the reliable signal
+    for "is this named entity actually written in the corpus", as opposed to
+    semantic search which always returns nearest neighbors regardless of relevance.
+    """
+    if not term.strip() or collection.count() == 0:
+        return False
+    for variant in _term_variants(term):
+        if not variant.strip():
+            continue
+        try:
+            raw = collection.query(
+                query_texts=[variant],
+                where_document={"$contains": variant},
+                n_results=1,
+                include=["metadatas"],
+            )
+        except Exception:
+            continue
+        if raw.get("ids", [[]])[0]:
+            return True
+    return False
+
+
+def search_by_keyword(
+    collection: chromadb.Collection,
+    terms: list[str],
+    n_results: int = 10,
+) -> list[dict]:
+    """
+    Exact-substring search using ChromaDB's where_document $contains filter.
+    Searches all spacing/hyphen variants of each term so "SPG302", "SPG 302",
+    and "SPG-302" all resolve to the same papers. Catches proper nouns (drug
+    codes, gene IDs) whose embeddings are meaningless to the model.
+    """
+    if not terms or collection.count() == 0:
+        return []
+
+    seen: dict[str, dict] = {}
+    for term in terms:
+        if not term.strip():
+            continue
+        for variant in _term_variants(term):
+            if not variant.strip():
+                continue
+            try:
+                raw = collection.query(
+                    query_texts=[variant],
+                    where_document={"$contains": variant},
+                    n_results=min(n_results, collection.count()),
+                    include=["documents", "metadatas", "distances"],
+                )
+            except Exception:
+                continue
+            for r in _parse_raw(raw):
+                pmid = r["pmid"]
+                if pmid not in seen or r["similarity"] > seen[pmid]["similarity"]:
+                    seen[pmid] = r
+
+    return _dedup_by_pmid(list(seen.values()))
+
+
 def rrf_merge(
     ranked_lists: list[list[dict]],
     k: int = RRF_K,
@@ -125,15 +274,31 @@ def cross_encoder_rerank(
     return candidates[:top_n]
 
 
+_RECENCY_BASE_YEAR = 1990
+_RECENCY_CURRENT_YEAR = 2025
+_RECENCY_MAX_BOOST = 0.5  # most recent papers get 1.5× vs oldest at 1.0×
+
+
 def apply_citation_boost(results: list[dict]) -> list[dict]:
     """
-    Final score = cross_encoder_score × log(citation_count + 2).
-    Applied after cross-encoder so citation quality amplifies — not corrupts — relevance.
-    log(2) ≈ 0.69 is the floor for uncited papers.
+    Final score = ce_score × log(citation_count + 2) × recency_factor.
+
+    Citation factor: log-scaled so each order-of-magnitude in citations adds
+    roughly equal weight. log(2) ≈ 0.69 floor for uncited papers.
+
+    Recency factor: linear 1.0 → 1.5 from 1990 to 2025. A 2024 paper scores
+    50% higher than a 1990 paper at equal citation count and relevance, reflecting
+    that recent evidence is more likely to reflect current understanding.
     """
     for r in results:
         base = r.get("ce_score", r.get("similarity", 0.0))
-        r["score"] = base * math.log(r["citation_count"] + 2)
+        citation_factor = math.log(r["citation_count"] + 2)
+        year = r.get("year") or _RECENCY_BASE_YEAR
+        recency_factor = 1.0 + _RECENCY_MAX_BOOST * (
+            max(0, year - _RECENCY_BASE_YEAR)
+            / (_RECENCY_CURRENT_YEAR - _RECENCY_BASE_YEAR)
+        )
+        r["score"] = base * citation_factor * recency_factor
     results.sort(key=lambda x: x["score"], reverse=True)
     return results
 

scripts/ingest_trials.py

@@ -1,11 +1,12 @@
 #!/usr/bin/env python3
 """
 Ingest ALS clinical trials from ClinicalTrials.gov v2 API.
+Fetches ALL statuses (recruiting, completed, terminated, withdrawn, etc.)
+so physicians can see the full trial landscape including failed trials.
 
 Usage:
     uv run python scripts/ingest_trials.py
-    uv run python scripts/ingest_trials.py --status RECRUITING
-    uv run python scripts/ingest_trials.py --status RECRUITING NOT_YET_RECRUITING COMPLETED
+    uv run python scripts/ingest_trials.py --upsert
 """
 from __future__ import annotations
 
@@ -28,22 +29,8 @@ from ingestion.clinicaltrials import fetch_als_trials
 
 console = Console()
 
-_ALL_STATUSES = ["RECRUITING", "COMPLETED", "ACTIVE_NOT_RECRUITING", "NOT_YET_RECRUITING"]
-
-
 def main() -> None:
     parser = argparse.ArgumentParser(description="Ingest ALS clinical trials")
-    parser.add_argument(
-        "--status",
-        nargs="+",
-        default=["RECRUITING", "NOT_YET_RECRUITING", "ACTIVE_NOT_RECRUITING"],
-        choices=_ALL_STATUSES,
-        metavar="STATUS",
-        help=(
-            f"One or more trial statuses to fetch (default: RECRUITING NOT_YET_RECRUITING "
-            f"ACTIVE_NOT_RECRUITING). Choices: {_ALL_STATUSES}"
-        ),
-    )
     parser.add_argument("--upsert", action="store_true", help="Merge fetched trials into existing trials.jsonl by nct_id")
     args = parser.parse_args()
 
@@ -51,8 +38,8 @@ def main() -> None:
 
     client = anthropic.Anthropic()
 
-    console.print(f"[cyan]Fetching ALS interventional trials (status={args.status})...[/cyan]")
-    trials = fetch_als_trials(status=args.status, client=client)
+    console.print("[cyan]Fetching all ALS interventional trials (no status filter)...[/cyan]")
+    trials = fetch_als_trials(client=client)
     console.print(f"[green]Fetched {len(trials)} trials[/green]")
 
     if args.upsert and TRIALS_PATH.exists():

uv.lock

@@ -453,6 +453,7 @@ dependencies = [
     { name = "networkx" },
     { name = "openai" },
     { name = "python-dotenv" },
+    { name = "rapidfuzz" },
     { name = "rich" },
     { name = "sentence-transformers" },
 ]
@@ -479,6 +480,7 @@ requires-dist = [
     { name = "pytest-httpx", marker = "extra == 'dev'", specifier = ">=0.35" },
     { name = "pytest-mock", marker = "extra == 'dev'", specifier = ">=3.14" },
     { name = "python-dotenv", specifier = ">=1.2.2" },
+    { name = "rapidfuzz", specifier = ">=3.14.5" },
     { name = "rich", specifier = ">=13.0.0" },
     { name = "sentence-transformers", specifier = ">=3.0.0" },
 ]
@@ -3030,6 +3032,85 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
 ]
 
+[[package]]
+name = "rapidfuzz"
+version = "3.14.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2c/21/ef6157213316e85790041254259907eb722e00b03480256c0545d98acd33/rapidfuzz-3.14.5.tar.gz", hash = "sha256:ba10ac57884ce82112f7ed910b67e7fb6072d8ef2c06e30dc63c0f604a112e0e", size = 57901753, upload-time = "2026-04-07T11:16:31.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/f9/3c41a7be8855803f4f6c713b472226a98d31d41869d98f64f4ca790510d6/rapidfuzz-3.14.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e251126d48615e1f02b4a178f2cd0cd4f0332b8a019c01a2e10480f7552554b4", size = 1952372, upload-time = "2026-04-07T11:13:58.32Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/89/c2557e37531d03465193bff0ab9de70b468420a807d71a26a65100635459/rapidfuzz-3.14.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ab449c9abd0d4e1f8145dce0798a4c822a1a1933d613c764a641bea88b8bdab", size = 1159782, upload-time = "2026-04-07T11:14:00.127Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/b2/ffeeb7eca1a897d51b998f4c0ef0281696c3b06abcca4f88f9def708ffe1/rapidfuzz-3.14.5-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cb2829fedd672dd7107267189dabe2bbe07972801d636014417c6861eb89e358", size = 1383677, upload-time = "2026-04-07T11:14:01.696Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/d0/4539e42a2d596e068f7738f279638a4a74edd1fbb6f8594e2458058979c6/rapidfuzz-3.14.5-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d50e5861872935fece391351cbb5ba21d1bced277cf5e1143d207a0a35f1925", size = 3168906, upload-time = "2026-04-07T11:14:03.29Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/1c/3ec897eb9d8b05308aa8ef6ae4ed64b088ad521a3f9d8ff469e7e97bc2b0/rapidfuzz-3.14.5-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:7092a216728f80c960bd6b3807275d1ee318b168986bd5dc523349581d4890b8", size = 1478176, upload-time = "2026-04-07T11:14:04.94Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ba/970c03a12ce20a5399e22afe9f8932fd4cd1265b8a8461d0e63b00eb4eae/rapidfuzz-3.14.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9669753caef7fdc6529f6adcc5883ed98d65976445d9322e7dbdb6b697feee13", size = 2402441, upload-time = "2026-04-07T11:14:07.228Z" },
+    { url = "https://files.pythonhosted.org/packages/81/93/61d351cae60c1d0e21ba5ff1a1015ad045539ed215da9d6e302204ed887a/rapidfuzz-3.14.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:823b1b9d9230809d8edcc18872770764bfe8ef4357995e16744047c8ccf0e489", size = 2511628, upload-time = "2026-04-07T11:14:09.234Z" },
+    { url = "https://files.pythonhosted.org/packages/87/52/374d2d4f60fd98155142a869323aa221e30868cfa1f15171a0f64070c247/rapidfuzz-3.14.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f0b2af76b7e7060c09e1a0dfa9410eb19369cbe6164509bff2ef94094b54d2b6", size = 4275480, upload-time = "2026-04-07T11:14:11.332Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/04/82e7989bc9ec20a15b720a335c5cb6b0724bf6582013898f90a3280cfccd/rapidfuzz-3.14.5-cp311-cp311-win32.whl", hash = "sha256:c5801a89604c65ab4cc9e91b23bc4076d0ca80efd8c976fb63843d7879a85d7f", size = 1725627, upload-time = "2026-04-07T11:14:13.217Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/b5/eca8ac5609bc9bcb02bb6ff87fa5983cc92b8772d66a431556ab8a8c178f/rapidfuzz-3.14.5-cp311-cp311-win_amd64.whl", hash = "sha256:d7ca16637c0ede8243f84074044bd0b2335a0341421f8227c85756de2d18c819", size = 1545977, upload-time = "2026-04-07T11:14:14.766Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/e1/dbf318de28f65fa2cdd0a9dfbdee380f8199eb83b19259bc4f8592551b4e/rapidfuzz-3.14.5-cp311-cp311-win_arm64.whl", hash = "sha256:8c90cdf8516d9057e502aa6003cea71cf5ec27cc44699ca52412b502a04761bb", size = 816827, upload-time = "2026-04-07T11:14:16.788Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/e3/574435c6aafb80254c191ef40d7aca2cb2bb97a095ec9395e9fa59ac307a/rapidfuzz-3.14.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0d3378f471ef440473a396ce2f8e97ee12f89a78b495540e0a5617bbfe895638", size = 1944601, upload-time = "2026-04-07T11:14:18.771Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/1f/fbad3102a255ecc112ce9a7e779bacab7fd14398217be8868dc9082ba363/rapidfuzz-3.14.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e910eebca9fd0eba245c0555e764597e8a0cccb673a92da2dc2397050725f48", size = 1164293, upload-time = "2026-04-07T11:14:20.534Z" },
+    { url = "https://files.pythonhosted.org/packages/88/37/a3eb7ff6121ed3a5f199a8c38cc86c8e481816f879cb0e0b738b078c9a7e/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:01550fe5f60fd176aa66b7611289d46dc4aa4b1b904874c7b6d1d54e581c5ec1", size = 1371999, upload-time = "2026-04-07T11:14:22.63Z" },
+    { url = "https://files.pythonhosted.org/packages/79/72/97a9728c711c7c1b06e107d3f0623880fb4ef90e147ed13c551a1730e7cc/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:48bee0b91bebfaec41e1081e351000659ab7570cc4598d617aa04d5bf827f9e6", size = 3145715, upload-time = "2026-04-07T11:14:24.508Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/54/d5caabbea233ac90c286c87c260e49d7641467e87438a18d858e41c82e91/rapidfuzz-3.14.5-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:7e580cb04ad849ae9b786fa21383c6b994b6e6c1444ad1cb9f22392759d72741", size = 1456304, upload-time = "2026-04-07T11:14:26.515Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/a7/2d1a81250ac8c01a0100c026018e76f0e7a097ff63e4c553e02a6938c6fb/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:09d6c9ba091854f07817055d795d604179c12a8f308ba4c7d56f3719dfea1646", size = 2389089, upload-time = "2026-04-07T11:14:28.635Z" },
+    { url = "https://files.pythonhosted.org/packages/65/0d/c47c3872203ae88e6506997c0b576ad731f5261daa25d559be09c9756658/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1e989f86113be66574113b9c7bdf4793f3f863d248e47d911b355e05ca6b6b10", size = 2493404, upload-time = "2026-04-07T11:14:30.577Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/2f/71e0a5a3130792146c8a200a2dd1e52aa16f7c1074012e17f2601eea9a90/rapidfuzz-3.14.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0ebd1a18e2e47bc0b292a07e6ed9c3642f8aaa672d12253885f599b50807a4f9", size = 4251709, upload-time = "2026-04-07T11:14:32.451Z" },
+    { url = "https://files.pythonhosted.org/packages/86/45/d39874901abacef325adb5b34ae416817c8486dfb4fb87c7a9b74ec5b072/rapidfuzz-3.14.5-cp312-cp312-win32.whl", hash = "sha256:9981d38a703b86f0e315a3cd229fd1906fe1d91c989ed121fb975b3c849f89f5", size = 1710069, upload-time = "2026-04-07T11:14:34.37Z" },
+    { url = "https://files.pythonhosted.org/packages/85/0b/f65572c53de8a1c704bda707f63a447b67bdbe95d7cdc70d18885e191df5/rapidfuzz-3.14.5-cp312-cp312-win_amd64.whl", hash = "sha256:d8375e3da319593389727c3187ccaf3e0e84199accc530866b8e0f2b79af05e9", size = 1540630, upload-time = "2026-04-07T11:14:36.287Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/c3/143be3a578f989758cae516f3270d5cbb49783a7bfdf57cc27a670e00456/rapidfuzz-3.14.5-cp312-cp312-win_arm64.whl", hash = "sha256:478b59bb018a6780d73f33e38d0b3ec5e968a6c1ed42876b993dd456b7aa20e8", size = 813137, upload-time = "2026-04-07T11:14:38.289Z" },
+    { url = "https://files.pythonhosted.org/packages/11/66/252803f2010ba699618cdc048b6e1f7cc1f433c08b4a9a17579b92ab0142/rapidfuzz-3.14.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ebd8fd343bf8492a1e60bcb6dc99f90f74f65d98d8241a6b3e1fed225b76ecd6", size = 1940205, upload-time = "2026-04-07T11:14:40.319Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/59/b2afd98e41af9cd54554a4c1c423d84cdd60e6b1c0a09496f033b55f60ec/rapidfuzz-3.14.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6737b35d5af7479c5bf9710f7b17edd9d2c43128d974d25fb4ea653e42c64609", size = 1159639, upload-time = "2026-04-07T11:14:42.52Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/31/7aa7e62c4c516a7af322ed0c4f0774208b72d457d0cfec808bad0df12f4a/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b002c7994cc9f2bc9d9856f0fbaee6e8072c983873846c92f25cefba5b2a925f", size = 1367194, upload-time = "2026-04-07T11:14:44.25Z" },
+    { url = "https://files.pythonhosted.org/packages/90/79/2fc252a63bc91d3c3b234d0a3a6ad4ebc460037a23cdcdaf9285f986e6c9/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:17a34330cd2a538c1ce5d400b61ba358c5b72c654b928ff87b362e88f8b864c7", size = 3151805, upload-time = "2026-04-07T11:14:46.21Z" },
+    { url = "https://files.pythonhosted.org/packages/17/54/0c83508f2683ea70e2d05f8527eb07328acf7bb1e9d97a3bece5702378e7/rapidfuzz-3.14.5-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:95d937e74c1a7a1287dfb03b62a827be08ede10a155cf1af73bbf47f2b73ee6e", size = 1455667, upload-time = "2026-04-07T11:14:47.991Z" },
+    { url = "https://files.pythonhosted.org/packages/71/1b/070175e873177814d58850a01ebe80e20ae11e93eb4da894d563988660fa/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:46b92a9970dcc34f0096901c792644094cab49554ac3547f35e3aebbdf0a3610", size = 2388246, upload-time = "2026-04-07T11:14:50.098Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/dd/77caf7aaf9c2be050ad1f128d7c24ff0f59079aa62c5f62f9df41c0af45e/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e012177c8e8a8a0754ae0d6027d63042aa5ff036d9f40f07cb3466a6082e21b8", size = 2494333, upload-time = "2026-04-07T11:14:52.303Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/e2/dd7e1f2aa31a8fbbfc16b0610af1d770ffaf1287490f3c8c5b1c52da264f/rapidfuzz-3.14.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a2ae6f53f99c9a0eca7a0afc5b4e45fc73bc1dd4ac74c00509031d76df80ed98", size = 4258579, upload-time = "2026-04-07T11:14:54.538Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/0a/ac99e1ba347ba0e85e0bb60b74231d55fb93c0eff43f2920ccb413d0be08/rapidfuzz-3.14.5-cp313-cp313-win32.whl", hash = "sha256:4a60f0057231188e3bd30216f7b4e0f279b11fa4ec818bb6c1d9f014d1562fbc", size = 1709231, upload-time = "2026-04-07T11:14:56.524Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/cb/0e251d731b3166378644238e8f0cf9e89858c024e19f75ca9f7e3ae83fd5/rapidfuzz-3.14.5-cp313-cp313-win_amd64.whl", hash = "sha256:11bfc2ed8fbe4ab86bd516fadefab126f90e6dcadffa761739fcb304707dfd35", size = 1538519, upload-time = "2026-04-07T11:14:58.635Z" },
+    { url = "https://files.pythonhosted.org/packages/30/6f/4548132acc947db6d5346a248e44a8b3a22d608ef30e770fb578caaf2d00/rapidfuzz-3.14.5-cp313-cp313-win_arm64.whl", hash = "sha256:b486b5218808f6f4dc471b114b1054e63553db69705c97da0271f47bd706aedd", size = 812628, upload-time = "2026-04-07T11:15:00.552Z" },
+    { url = "https://files.pythonhosted.org/packages/00/60/69b177577290c5eab892c6f75fe89c3aff3f9ae80298a78d9372b1cecb9a/rapidfuzz-3.14.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:39ef8658aaf67d51667e7bdaf7096f432333377d8302ac43c70b5df8a4cf89b8", size = 1970231, upload-time = "2026-04-07T11:15:02.603Z" },
+    { url = "https://files.pythonhosted.org/packages/48/38/2fd790052659cc4e2907b63c25433f0987864b445c1aeec1a302ef5ad948/rapidfuzz-3.14.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:9ad37a0be705b544af6296da8edddc260d10a8ae5462530fc9991f66498bb1f9", size = 1194394, upload-time = "2026-04-07T11:15:04.572Z" },
+    { url = "https://files.pythonhosted.org/packages/80/f4/28430ad8472fc3536e8ebd51a864a226e979cfe924c6e3f83d111373aa74/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d45e06f60729e07d9b20c205f7e5cff90b6ef2584e852eecf46e045aea69627d", size = 1377051, upload-time = "2026-04-07T11:15:06.728Z" },
+    { url = "https://files.pythonhosted.org/packages/77/7e/9aeacabcfd1e77397968362e5b98fe14248b8307011136b17daf99752a8e/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e52da10236aa6212de71b9e170bace65b64b129c0dea7fc243d6c9ce976f5074", size = 3160565, upload-time = "2026-04-07T11:15:08.667Z" },
+    { url = "https://files.pythonhosted.org/packages/56/f4/db4dd7be0cd2f2022117ac5407d905f435d60e48baaea313a567ad27e865/rapidfuzz-3.14.5-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:440d30faaf682ca496170a7f0cc5453ec942e3e079f0fd802c9a7f938dfb50a3", size = 1442113, upload-time = "2026-04-07T11:15:11.138Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/99/0e9f6aa57f3e32a767216f797e56dc96b720fcecfb9d8ee907ecc82f8d66/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:56227a61fd3d17b0cd9793132431f3a3d07c8654be96794ba9f89fe0fc8b2d09", size = 2396618, upload-time = "2026-04-07T11:15:13.154Z" },
+    { url = "https://files.pythonhosted.org/packages/60/94/44a78e39ffce17cbdd3e2b53b696acc751d5d153be0f499d052b07a4d904/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:2e83cd2e25bb4edd97b689d9979d9c3acccdaaf26ceac08212ceece202febcfa", size = 2478220, upload-time = "2026-04-07T11:15:15.193Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/df/454311469a09a507e9d784a35796742bec22e4cebe75551e2da4e0e290fd/rapidfuzz-3.14.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:af3b859726cd3374287e405e14b9634563c078c5531a4f62375508addebddad1", size = 4265027, upload-time = "2026-04-07T11:15:17.28Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/01/175465a9ab3e3b70ba669058372f009d1d49c1746e2dcd56b69df188d3a5/rapidfuzz-3.14.5-cp313-cp313t-win32.whl", hash = "sha256:8ce1d850b3c0178440efde9e884d98421b5e87ff925f364d6d79e23910d7593f", size = 1766814, upload-time = "2026-04-07T11:15:19.687Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/a0/a9b84a47af06ebed94a1439eb2f02adebfb8628bcd30af1fe3e02f5ef56c/rapidfuzz-3.14.5-cp313-cp313t-win_amd64.whl", hash = "sha256:c84af70bcf34e99aee894e46a0f1ac77f17d0ef828179c387407642e2466d28a", size = 1582448, upload-time = "2026-04-07T11:15:21.98Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/f1/5937800238b3f8248e70860d79f69ba8f73e764fff47e36bc9e2f26dbcc6/rapidfuzz-3.14.5-cp313-cp313t-win_arm64.whl", hash = "sha256:aac0ad28c686a5e72b81668b906c030ee28050b244544b8af68e12fb32543895", size = 832932, upload-time = "2026-04-07T11:15:24.358Z" },
+    { url = "https://files.pythonhosted.org/packages/81/41/aa3ffb3355e62e1bf91f6599b3092e866bc88487a07c524004943c7676df/rapidfuzz-3.14.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1a31cc6d7d03e7318a0974c038959c59e19c752b81115f2e9138b3331cd64d45", size = 1943327, upload-time = "2026-04-07T11:15:26.266Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/e1/c2141f1840a41e07ad2db6f724945f8f8ff3065463899a22939152dd6e09/rapidfuzz-3.14.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0298d357e2bc59d572da4db0bc631009b6f8f6c9bc8c11e99a12b833f16b6575", size = 1161755, upload-time = "2026-04-07T11:15:28.659Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/07/66e753eeaa353161d1d331b7dd517bb349b0bacfebe8496d7b26be26f81f/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:59b3dba758661a318995655435c6ab20a04ade79fa51e75bc8dc107cac8df280", size = 1376571, upload-time = "2026-04-07T11:15:31.225Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/85/9535df0b78ba51f478c9ce7eb6d1f85535cc31fe356773b48fd9d3e563ca/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4900143d82071bdda533b00300c40b14b963ff826b3642cc463b6dd0f036585e", size = 3156468, upload-time = "2026-04-07T11:15:33.428Z" },
+    { url = "https://files.pythonhosted.org/packages/81/ee/b667eb93bba6dc4e0de658edd778e1619dc4d6aab68fa5e5c7f075152735/rapidfuzz-3.14.5-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:feedf219672eef83ea6be6f3bb093bba396a8560fc75be85ba225f082903df0a", size = 1458311, upload-time = "2026-04-07T11:15:35.557Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/ce/479074f5624364a48df3403c538797ef22d3ac49c19dc76c3f79fcdcc70c/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:419e4397a36e2665ec992d8d64c20ba4b2a42500c76ecadeca78a4f19cb9cc32", size = 2398228, upload-time = "2026-04-07T11:15:37.669Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/15/a8982f649150fffbdcd6f17565974501f6ab33b2795267bffbd4a7ba905b/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:97131ab2be39043054ee28d99e09efe316e6d53449b7e962dfcf3c2de8b2b246", size = 2497226, upload-time = "2026-04-07T11:15:39.857Z" },
+    { url = "https://files.pythonhosted.org/packages/19/52/5267c03ef6759831b7d4625a0c9c06e87baa2fae084b61ac9c388858317b/rapidfuzz-3.14.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:593c00dac4e30231c35bf3b4f1da8ec0998762e9e94425586a5d636fcd57f9d0", size = 4262283, upload-time = "2026-04-07T11:15:42.279Z" },
+    { url = "https://files.pythonhosted.org/packages/71/c0/2579f343a97f5254c43bb5853baccc01488357dcb64a27bcb869b7888a4a/rapidfuzz-3.14.5-cp314-cp314-win32.whl", hash = "sha256:0084b687b02b4e569b46d8d6d4ad25659528e6081cd6d067ca453a69035f07e4", size = 1744614, upload-time = "2026-04-07T11:15:44.498Z" },
+    { url = "https://files.pythonhosted.org/packages/17/eb/8edfed1e80119dc9c35b11df4bc701eea85622ad681fff0263b6961d3224/rapidfuzz-3.14.5-cp314-cp314-win_amd64.whl", hash = "sha256:5dfa89d78f22cd773054caff44827b846161a29f2dcf7e78b8f90d086621e502", size = 1588971, upload-time = "2026-04-07T11:15:46.86Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/04/5676df93c85cfa57a3045d8047318df9f3cd58c7b8a99340dd95f874795e/rapidfuzz-3.14.5-cp314-cp314-win_arm64.whl", hash = "sha256:67f3f9d2b444268ab53e47d31bab89954888d23c04c6789f2c727e51fe4b1d13", size = 834985, upload-time = "2026-04-07T11:15:49.411Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/0d/4a8988cea658fe335048ddef8c876addff1b6daa3c9ca8ad65a5a2196e69/rapidfuzz-3.14.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:77eac0526899b3c3ad1454bb2b03cdb491d67358ec8ef0c9c48bd61b632b431d", size = 1972517, upload-time = "2026-04-07T11:15:51.819Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/a3/f5cfd9965a9d9a9e32249159797c47b5d6299ea6d1629f9126b25f1c10a3/rapidfuzz-3.14.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b9c6bd754d11f6e78ac54e3d86b4b11dc1ba2f13e5fc958899574532897f5a99", size = 1196056, upload-time = "2026-04-07T11:15:54.292Z" },
+    { url = "https://files.pythonhosted.org/packages/64/07/561c2e40cfd10e6630a7b0ac5a2a813aef50d944bcd1f3d260319d659d5b/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:738c96944d076deeaff70e92b65696ab4f7ecb8081d7791c5403a3257dfaf8ff", size = 1374732, upload-time = "2026-04-07T11:15:56.584Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/39/123bb94fee40e2fb3b7c49b80827c7ef42d838e18def3fc2fef5a3cf817a/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4c1bca487a17fe4226b4ffb2d30e799d2b274d692cffa76bd0746f56235fca3", size = 3166902, upload-time = "2026-04-07T11:15:58.768Z" },
+    { url = "https://files.pythonhosted.org/packages/75/0a/45716fafc9fd2e028cf20b5ac5bc704887081cd312f84edb0e325599414b/rapidfuzz-3.14.5-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:af6a90a4ed2a48fa1a2d17e9d824e6c7c950bea5bad0b707c77fd55751e6bfef", size = 1452130, upload-time = "2026-04-07T11:16:01.453Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/49/4e96c413114398481c0a5b0086af32c364a18613c9a2ea578d17c4bea4ee/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bf5018938208d4597b2e679a4f8cff9fd252f1df53583130ae56281a21801b64", size = 2396308, upload-time = "2026-04-07T11:16:03.588Z" },
+    { url = "https://files.pythonhosted.org/packages/89/b7/49fea9fc6878d59bd259d01dd1972d9b86117992b1c66d9b16f0a65273c3/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c0919d1f89ddf91129906705723118ea09754171e4116f5a5dbc667c7bc9b261", size = 2488210, upload-time = "2026-04-07T11:16:05.871Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/44/a1f732b93ffacbdad077b7c801149549b2938e1bece6addb5ad85ed74df8/rapidfuzz-3.14.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:93d8da883a35116d6813432177f35e570db5b0a5e30ecb0cbd7cb39c815735df", size = 4270621, upload-time = "2026-04-07T11:16:08.483Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/ce/ff942d19fce5385054650bb71a58495ddda299d94661ccc4e6e7fa44868b/rapidfuzz-3.14.5-cp314-cp314t-win32.whl", hash = "sha256:0f23e37019ec07712d58976b1ab2b889f8649a7f7c2f626a2f34ea9139e79279", size = 1803950, upload-time = "2026-04-07T11:16:10.873Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/0f/9aafc63f9661222b819b391c187eed29fc90ad5935f9690e5ecc2d2047a4/rapidfuzz-3.14.5-cp314-cp314t-win_amd64.whl", hash = "sha256:7d5ca9c7832e6879a707296d1463685f7c243a27846227044504741640caec66", size = 1632357, upload-time = "2026-04-07T11:16:13.1Z" },
+    { url = "https://files.pythonhosted.org/packages/70/a6/51fc1b0e61e3326e1c68a61cfd0c6b3c34c843681c4b1eefbf0596f59162/rapidfuzz-3.14.5-cp314-cp314t-win_arm64.whl", hash = "sha256:3e91dcd2549b8f8d843f98ba03a17e01f3d8b72ce942adbbb6761bc58ffce813", size = 855409, upload-time = "2026-04-07T11:16:15.787Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/ee/e71853bf82846c5c2174b924b71d8e8099fb05ff87c958a720380b434ba3/rapidfuzz-3.14.5-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:578e6051f6d5e6200c259b47a103cf06bb875ab5814d17333fc0b5c290b22f4c", size = 1888603, upload-time = "2026-04-07T11:16:18.223Z" },
+    { url = "https://files.pythonhosted.org/packages/36/82/40f67b730f32be2ebad9f62add1571c754f52249254b2e88af094b907eee/rapidfuzz-3.14.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:fbf1b8bb2695415b347f3727da1addca2acb82c9b97ac86bebf8b1bead1eb12d", size = 1120599, upload-time = "2026-04-07T11:16:20.682Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/9f/a3635cc4ec8fc6e14b46e7db1f7f8763d8c4bef33dcc124eea2e6cb2c8f3/rapidfuzz-3.14.5-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f4a8f5cc84c7ad6bffa0e9947b33eb343ad66e6b53e94fe54378a5508c5ed53", size = 1348524, upload-time = "2026-04-07T11:16:23.451Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/1b/2b229520f0b48464cfcd7aa758f74551d12c9bc4ab544022a60210aab064/rapidfuzz-3.14.5-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:97c6d85283629646fa87acc22c66b30ea9d4de7f6fdf887daa2e30fa041829b5", size = 3099302, upload-time = "2026-04-07T11:16:25.858Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b5/363906b1064fc6fe611783a61764927bbd91919aaaabe8cba82151ca93ef/rapidfuzz-3.14.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:dfef96543ced67d9513a422755db422ae1dc34dade0a1485e0b43e7342ed3ebf", size = 1509889, upload-time = "2026-04-07T11:16:28.487Z" },
+]
+
 [[package]]
 name = "referencing"
 version = "0.37.0"