Sync from GitHub via hub-sync

.dockerignore

@@ -0,0 +1,3 @@
+drugbank-mcp-server/node_modules/
+drugbank-mcp-server/data/
+drugbank-mcp-server/build/

.zenodo.json

@@ -0,0 +1,20 @@
+{
+    "description": "PillChecker is an open-source API and benchmarking suite for identifying pharmaceutical ingredients from OCR text and checking for potential drug-drug interactions. It features a multi-agent NER pipeline using PharmaDetect and GLiNER, and validates results against RxNorm and DrugBank.",
+    "creators": [
+        {
+            "name": "Perekrestova, Svetlana",
+            "affiliation": "Independent Researcher"
+        }
+    ],
+    "keywords": [
+        "pharmaceutical-ner",
+        "drug-interactions",
+        "nlp",
+        "ocr-cleaning",
+        "benchmarking",
+        "mcp"
+    ],
+    "license": "MIT",
+    "title": "PillChecker API: Pharmaceutical Entity Extraction and Interaction Checker",
+    "access_right": "open"
+}

CITATION.cff

@@ -0,0 +1,18 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+authors:
+- family-names: "Perekrestova"
+  given-names: "Svetlana"
+  orcid: "https://orcid.org/0009-0003-2905-6040"
+title: "PillChecker API: A Multi-Agent System for Pharmaceutical Entity Extraction and Interaction Checking"
+version: 1.2.2
+doi: 10.5281/zenodo.19792062
+date-released: 2026-04-26
+url: "https://github.com/SPerekrestova/pillchecker-api"
+keywords:
+  - pharmaceutical-ner
+  - drug-interactions
+  - ocr-correction
+  - nlp
+  - benchmarking
+license: MIT

Dockerfile

@@ -1,12 +1,11 @@
 FROM ghcr.io/astral-sh/uv:0.9-python3.12-bookworm-slim AS builder
 
-# Set the same path as the final runtime for venv portability
-WORKDIR /home/user/app
+WORKDIR /app
 
 # Copy dependency files first for layer caching
 COPY pyproject.toml uv.lock .python-version ./
 
-# Install dependencies only
+# Install dependencies only (locked, no project code yet)
 RUN uv sync --no-install-project --no-dev
 
 # Copy application code and install the project
@@ -19,6 +18,7 @@ FROM python:3.12-slim AS db-downloader
 WORKDIR /app/drugbank-mcp-server/data
 
 # Use curl to download a pinned version of the pre-built SQLite DB.
+# Pinning the tag ensures deterministic builds and allows Docker to cache this layer reliably.
 ARG DRUGBANK_DB_REPO=openpharma-org/drugbank-mcp-server
 ARG DRUGBANK_DB_TAG=db-2026-04-01
 RUN apt-get update && apt-get install -y curl && \
@@ -28,36 +28,38 @@ RUN apt-get update && apt-get install -y curl && \
 # --- Runtime stage ---
 FROM python:3.12-slim
 
-# HF Spaces user is 1000
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
-    PATH=/home/user/app/.venv/bin:/home/user/.local/bin:$PATH \
-    HF_HOME=/home/user/models \
-    TRANSFORMERS_CACHE=/home/user/models
+WORKDIR /app
 
-WORKDIR $HOME/app
-
-# Copy built virtualenv from builder (path now matches)
-COPY --from=builder --chown=user:user /home/user/app/.venv $HOME/app/.venv
+# Copy built virtualenv from builder
+COPY --from=builder /app/.venv /app/.venv
 
 # Copy DrugBank SQLite DB from downloader stage
-COPY --from=db-downloader --chown=user:user /app/drugbank-mcp-server/data $HOME/app/drugbank-mcp-server/data
+COPY --from=db-downloader /app/drugbank-mcp-server/data /app/drugbank-mcp-server/data
+
+ENV PATH="/app/.venv/bin:$PATH"
+ENV HF_HOME=/app/models
+ENV TRANSFORMERS_CACHE=/app/models
 
-# Pre-download NER models so the image is self-contained.
+# Pre-download NER model so the image is self-contained.
+# Layer is cached until venv or model ID changes.
+# In local dev, docker-compose mounts a volume over /app/models.
 RUN python -c "from transformers import pipeline; \
     pipeline('ner', model='OpenMed/OpenMed-NER-PharmaDetect-BioPatient-108M', aggregation_strategy='none'); \
     pipeline('zero-shot-classification', model='MoritzLaurer/DeBERTa-v3-base-mnli-fever-anli')"
 
 # App code comes last — most frequently changing layer
-COPY --from=builder --chown=user:user /home/user/app/app $HOME/app/app
-COPY --chown=user:user scripts/ $HOME/scripts/
+COPY --from=builder /app/app /app/app
+COPY scripts/ /app/scripts/
+
+RUN chmod +x /app/scripts/prod-startup.sh /app/scripts/ci-startup.sh
 
-RUN chmod +x $HOME/scripts/prod-startup.sh
+# Create a non-root user for security
+RUN groupadd -r pillchecker && useradd -r -g pillchecker pillchecker && \
+    chown -R pillchecker:pillchecker /app
 
-# HF Spaces expects port 7860
-EXPOSE 7860
+USER pillchecker
 
-ENTRYPOINT ["/home/user/scripts/prod-startup.sh"]
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]
+EXPOSE 8000
 
+ENTRYPOINT ["/app/scripts/prod-startup.sh"]
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,11 +1,106 @@
----
-title: Pillchecker Staging
-emoji: 📚
-colorFrom: green
-colorTo: indigo
-sdk: docker
-pinned: true
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PillChecker API
+
+PillChecker helps users find out if two medications are safe to take at the same time. This repository contains the backend API that identifies drugs from OCR text and checks for dangerous interactions using DrugBank pharmaceutical data.
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.19792062.svg)](https://doi.org/10.5281/zenodo.19792062)
+
+> **MEDICAL DISCLAIMER**
+>
+> This service is provided for **informational and self-educational purposes only**. While the application utilizes data from respected pharmaceutical sources, the information provided should **not** be treated as medical advice, diagnosis, or treatment.
+>
+> The developer of this project **does not have any medical qualifications**. This tool was built as a technical exercise to explore NLP and medical data integration.
+>
+> **Always consult with a qualified healthcare professional** (such as a doctor or pharmacist) before making any decisions regarding your medications or health. The developer assumes **no responsibility or liability** for any errors, omissions, or consequences arising from the use of the information provided by this service.
+
+## Architecture
+
+### Drug Identification
+
+Converts unstructured OCR text into standardized drug records using a multi-step strategy:
+
+1. **OCR Cleaning**: The `ocr_cleaner` normalizes common OCR artifacts before NER: digit-letter confusion (`0`/`o`, `1`/`l`), `rn`→`m` in drug names, ligatures, invisible characters, and whitespace.
+2. **NER**: The **[OpenMed-NER-PharmaDetect-BioPatient-108M](https://huggingface.co/OpenMed/OpenMed-NER-PharmaDetect-BioPatient-108M)** model (108M parameters) extracts chemical entity names from the cleaned text.
+3. **Fallback**: If NER yields no results, an approximate term search via the **RxNorm REST API** catches brand names (e.g., "Advil" -> ibuprofen).
+4. **Enrichment**: A regex parser extracts dosages (e.g., "400 mg"), and the RxNorm API maps every identified drug to its **RxCUI** for standardized downstream lookups.
+5. **Confidence**: Results with NER score below 0.85 or sourced from the RxNorm fallback are flagged with `needs_confirmation = true` to prompt user verification.
+
+### Interaction Checking
+
+Drug-drug interactions are resolved against the **DrugBank** pharmaceutical database via a vendored MCP server:
+
+1. **DrugBank MCP server**: A Node.js process (vendored under `drugbank-mcp-server/`) communicates over stdio using the Model Context Protocol. It serves a pre-built SQLite database (~17,400 drugs) with structured pairwise interaction data.
+2. **Bidirectional lookup**: For each drug pair, the checker queries both directions (A->B and B->A) in parallel using `asyncio.gather()`.
+3. **Severity classification**: Interaction descriptions are first parsed by a deterministic **template parser** that matches regex patterns in DrugBank text. If the parser cannot determine severity, a **DeBERTa v3** zero-shot classifier is used as fallback. Unknown severity defaults to `major` with `uncertain = true`.
+4. **Caching**: DrugBank interaction records are cached in-process for 4 hours; RxNorm lookups are cached for 24 hours.
+
+### Transparency
+
+Both `/analyze` and `/interactions` responses include:
+- `data_sources`: which models and databases were used for the result
+- `limitations` (interactions only): scope disclaimers about what the system does and does not cover
+
+### Docker Build
+
+The image uses a three-stage build to keep layers small and reproducible:
+
+- **Stage 1 (Python)**: `uv` installs Python dependencies into an isolated venv.
+- **Stage 2 (Node.js)**: `npm ci` installs Node dependencies; the DrugBank SQLite database is downloaded from GitHub Releases.
+- **Stage 3 (Runtime)**: Combines the venv, Node binary, and built MCP server. NER and severity models are pre-downloaded so the image is fully self-contained.
+
+## API Endpoints
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| `GET` | `/health` | No | Liveness check |
+| `GET` | `/health/data` | No | Readiness -- confirms DrugBank MCP connection |
+| `POST` | `/analyze` | API key | Extract drugs from OCR text |
+| `POST` | `/interactions` | API key | Check interactions for a list of drug names |
+| `POST` | `/admin/cache/clear` | API key | Clear all in-memory caches |
+
+## Eval Benchmark
+
+The benchmark suite and raw results have been migrated to the Hugging Face Hub for better reproducibility and visualization.
+
+*   **Benchmark Dataset:** [SPerva/pillchecker-ner-benchmark](https://huggingface.co/datasets/SPerva/pillchecker-ner-benchmark)
+*   **Result History:** [hf://buckets/SPerva/pillchecker-experiments](https://huggingface.co/buckets/SPerva/pillchecker-experiments)
+*   **Methodology:** See the dataset card on Hugging Face for details on the 11,796 synthesized cases.
+
+| Pipeline (Clean Text) | Precision | Recall | F1 |
+|------------------------|-----------|--------|----|
+| Bare NER Baseline | 46.9% | 84.4% | 60.3% |
+| Full Pipeline | 71.6% | 81.0% | 76.0% |
+| **GLiNER Union (Best)** | **78.0%** | **93.6%** | **85.1%** |
+
+## Staging & Deployment
+
+The API is deployed as a staging environment on Hugging Face Spaces for remote testing:
+
+*   **Staging Space:** [sperva-pillchecker-staging](https://huggingface.co/spaces/SPerva/pillchecker-staging)
+*   **API Docs:** [sperva-pillchecker-staging.hf.space/docs](https://sperva-pillchecker-staging.hf.space/docs)
+
+
+- **[PillChecker Collection](https://huggingface.co/collections/SPerva/pillchecker-69ee0f67dee76ff7ae9ea30a)** -- Central hub for all models and datasets used in this project.
+- **[OpenMed NER PharmaDetect](https://huggingface.co/OpenMed/OpenMed-NER-PharmaDetect-BioPatient-108M)** -- drug entity recognition model (108M params). License: Apache 2.0
+- **[RxNorm REST API](https://lhncbc.nlm.nih.gov/RxNav/APIs/RxNormAPIs.html)** -- drug name normalization and RxCUI mapping. Provided by NLM (free to use).
+- **[DrugBank](https://www.drugbank.com/)** -- pharmaceutical database providing structured drug-drug interaction data. Accessed via the [openpharma-org/drugbank-mcp-server](https://github.com/openpharma-org/drugbank-mcp-server) open-source MCP server.
+- **[DeBERTa-v3-base-mnli-fever-anli](https://huggingface.co/MoritzLaurer/DeBERTa-v3-base-mnli-fever-anli)** -- zero-shot classifier for interaction severity. License: MIT
+- **[Hugging Face Transformers](https://huggingface.co/docs/transformers)** -- NLP pipeline library. License: Apache 2.0
+
+## Citation
+
+If you use this software or the benchmark dataset in your research, please cite it as:
+
+```bibtex
+@software{perekrestova_pillchecker_2026,
+  author = {Perekrestova, Svetlana},
+  orcid = {0009-0003-2905-6040},
+  title = {PillChecker API: Pharmaceutical Entity Extraction and Interaction Checker},
+  version = {1.2.2},
+  doi = {10.5281/zenodo.19792062},
+  url = {https://github.com/SPerekrestova/pillchecker-api},
+  date = {2026-04-26},
+  publisher = {Zenodo},
+  note = {GitHub Repository}
+}
+```
+

app/nlp/gliner_model.py

@@ -1,48 +0,0 @@
-"""GLiNER model wrapper.
-
-Loads the model lazily and exposes a predict() function.
-"""
-
-from typing import List, Optional
-
-from app.nlp.ner_model import Entity
-from app.nlp.ingredient_labels import GLINER_LABELS
-
-_gliner_model = None
-MODEL_ID = "urchade/gliner_medium-v2.1"
-
-def load_model() -> None:
-    """Load the GLiNER model into memory lazily."""
-    global _gliner_model
-    if _gliner_model is None:
-        try:
-            from gliner import GLiNER
-        except ImportError:
-            raise RuntimeError("GLiNER is not installed. Install with `uv pip install gliner` or `pip install .[gliner]`")
-        
-        _gliner_model = GLiNER.from_pretrained(MODEL_ID)
-
-def is_loaded() -> bool:
-    """Check if the GLiNER model is loaded."""
-    return _gliner_model is not None
-
-def predict(text: str, labels: Optional[List[str]] = None, threshold: float = 0.5) -> List[Entity]:
-    """Extract entities using GLiNER."""
-    if _gliner_model is None:
-        load_model()
-    
-    if labels is None:
-        labels = GLINER_LABELS
-        
-    raw_entities = _gliner_model.predict_entities(text, labels, threshold=threshold)
-    
-    return [
-        Entity(
-            text=ent["text"],
-            label=ent["label"],
-            score=round(float(ent["score"]), 4),
-            start=ent["start"],
-            end=ent["end"],
-        )
-        for ent in raw_entities
-    ]

app/nlp/ingredient_labels.py

@@ -1,10 +0,0 @@
-"""GLiNER labels for ingredient evaluation."""
-
-GLINER_LABELS = [
-    "active pharmaceutical ingredient",
-    "salt or counter-ion",
-    "brand or trade name",
-    "manufacturer",
-    "dosage form",
-    "dosage strength"
-]

app/services/drug_analyzer.py

@@ -15,9 +15,6 @@ from app.middleware.audit_log import get_audit_context
 from app.nlp import ner_model
 from app.nlp.dosage_parser import Dosage, extract_dosages
 from app.nlp.ocr_cleaner import clean as ocr_clean
-import os
-
-NER_EXPERIMENT_MODE = os.getenv("NER_EXPERIMENT_MODE", "")
 
 logger = logging.getLogger(__name__)
 
@@ -78,86 +75,21 @@ async def analyze(text: str) -> list[dict]:
         and _is_valid_entity_name(e.text)
     ]
 
-    gliner_entities = []
-    if NER_EXPERIMENT_MODE:
-        from app.nlp import gliner_model
-        gliner_entities = gliner_model.predict(cleaned_text)
-        if ctx:
-            ctx.add("gliner", {
-                "entities": [{"text": e.text, "label": e.label, "score": e.score} for e in gliner_entities],
-            })
-
     if drug_entities:
         logger.info("NER found %d drug entities", len(drug_entities))
-        if NER_EXPERIMENT_MODE == "gliner_sequential":
-            from app.nlp import gliner_model
-            # For each PharmaDetect entity, run GLiNER on the snippet to classify it
-            verified_entities = []
-            for ent in drug_entities:
-                snippet_ents = gliner_model.predict(ent.text)
-                # Check if GLiNER thinks this snippet contains an active ingredient
-                is_active = any(g.label == "active pharmaceutical ingredient" for g in snippet_ents)
-                if is_active:
-                    verified_entities.append(ent)
-            
-            if verified_entities:
-                enriched = await _enrich_ner_results(verified_entities, dosages, source="gliner_sequential")
-            else:
-                enriched = []
-        else:
-            enriched = await _enrich_ner_results(drug_entities, dosages)
-        
-        if NER_EXPERIMENT_MODE in ("gliner_filter", "gliner_adjudicated"):
-            from app.services import ingredient_adjudicator
-            enriched = ingredient_adjudicator.adjudicate(NER_EXPERIMENT_MODE, enriched, gliner_entities)
-        
-        if NER_EXPERIMENT_MODE == "gliner_union":
-            # Extract active ingredients using GLiNER
-            gliner_active = [e for e in gliner_entities if e.label == "active pharmaceutical ingredient"]
-            if gliner_active:
-                gliner_enriched = await _enrich_ner_results(gliner_active, dosages, source="gliner_union")
-                # Union and deduplicate
-                seen_rxcuis = {e["rxcui"] for e in enriched if e.get("rxcui")}
-                for ge in gliner_enriched:
-                    if ge.get("rxcui") not in seen_rxcuis:
-                        enriched.append(ge)
-                        if ge.get("rxcui"):
-                             seen_rxcuis.add(ge["rxcui"])
-                enriched.sort(key=lambda r: r["confidence"], reverse=True)
-
+        enriched = await _enrich_ner_results(drug_entities, dosages)
         if enriched:
-            # Strip _entity before returning
-            for item in enriched:
-                item.pop("_entity", None)
-                item.pop("_rejected", None)
-                item.pop("_rejection_reason", None)
             return enriched
-            
         logger.info("All NER entities filtered out, trying RxNorm fallback")
 
-    # Pass 2: Fallback
+    # Pass 2: Fallback — try RxNorm approximate matching on text blocks
     logger.info("Falling through to RxNorm fallback")
-    
-    if NER_EXPERIMENT_MODE in ("gliner_fallback", "gliner_adjudicated"):
-        if not gliner_entities and NER_EXPERIMENT_MODE == "gliner_fallback":
-            from app.nlp import gliner_model
-            gliner_entities = gliner_model.predict(cleaned_text)
-            
-        gliner_active = [e for e in gliner_entities if e.label == "active pharmaceutical ingredient"]
-        if gliner_active:
-            gliner_enriched = await _enrich_ner_results(gliner_active, dosages, source="gliner_fallback_rxnorm")
-            if gliner_enriched:
-                for item in gliner_enriched:
-                    item.pop("_entity", None)
-                return gliner_enriched
-
     return await _rxnorm_fallback(text, dosage_str)
 
 
 async def _enrich_ner_results(
     entities: list[ner_model.Entity],
     dosages: list[Dosage],
-    source: str = "ner"
 ) -> list[dict]:
     """Enrich NER entities with RxNorm data."""
     results = []
@@ -180,10 +112,9 @@ async def _enrich_ner_results(
             "name": name,
             "dosage": _nearest_dosage(entity.end, dosages),
             "form": None,
-            "source": source,
+            "source": "ner",
             "confidence": entity.score,
             "needs_confirmation": entity.score < 0.85,
-            "_entity": entity,
         })
 
     results.sort(key=lambda r: r["confidence"], reverse=True)

app/services/ingredient_adjudicator.py

@@ -1,102 +0,0 @@
-"""Ingredient adjudicator to compare PharmaDetect, GLiNER, and RxNorm results."""
-
-from typing import List, Dict, Any
-
-def _spans_overlap(start1: int, end1: int, start2: int, end2: int) -> bool:
-    """Check if two character spans overlap."""
-    return max(start1, start2) < min(end1, end2)
-
-def _get_overlapping_labels(start: int, end: int, gliner_entities: List[Any]) -> List[Any]:
-    return [g for g in gliner_entities if _spans_overlap(start, end, g.start, g.end)]
-
-def _has_neighboring_active(start: int, end: int, gliner_entities: List[Any], distance: int = 20) -> bool:
-    for g in gliner_entities:
-        if g.label == "active pharmaceutical ingredient":
-            # Check if it's nearby
-            if min(abs(start - g.end), abs(end - g.start)) <= distance:
-                return True
-    return False
-
-def adjudicate_filter(
-    pharm_candidates: List[Dict[str, Any]], 
-    gliner_entities: List[Any]
-) -> List[Dict[str, Any]]:
-    """gliner_filter mode: precision filter."""
-    accepted = []
-    
-    for cand in pharm_candidates:
-        ent = cand.get("_entity")
-        if not ent:
-            accepted.append(cand)
-            continue
-            
-        overlaps = _get_overlapping_labels(ent.start, ent.end, gliner_entities)
-        overlap_labels = [g.label for g in overlaps]
-        
-        # Keep if GLiNER labels it as active ingredient
-        if "active pharmaceutical ingredient" in overlap_labels:
-            accepted.append(cand)
-            continue
-            
-        # If GLiNER labels as brand, manufacturer, dosage form, or salt
-        negative_labels = {"brand or trade name", "manufacturer", "dosage form", "salt or counter-ion"}
-        found_neg = set(overlap_labels).intersection(negative_labels)
-        
-        if found_neg:
-            # Reject unless it has a neighboring active ingredient
-            if not _has_neighboring_active(ent.start, ent.end, gliner_entities):
-                cand["_rejected"] = True
-                cand["_rejection_reason"] = f"GLiNER labeled as {', '.join(found_neg)}"
-                continue
-                
-        accepted.append(cand)
-        
-    return accepted
-
-def adjudicate_salt(
-    pharm_candidates: List[Dict[str, Any]], 
-    gliner_entities: List[Any]
-) -> List[Dict[str, Any]]:
-    """Salt-aware adjudicator."""
-    accepted = []
-    salt_words = {"Sodium", "Hydrochloride", "Calcium", "Phosphate", "Maleate", "Potassium"}
-    
-    for cand in pharm_candidates:
-        ent = cand.get("_entity")
-        if not ent:
-            accepted.append(cand)
-            continue
-            
-        overlaps = _get_overlapping_labels(ent.start, ent.end, gliner_entities)
-        overlap_labels = [g.label for g in overlaps]
-        
-        # If it's just a standalone salt word according to text
-        is_salt_word = ent.text in salt_words
-        is_gliner_salt = "salt or counter-ion" in overlap_labels
-        
-        if (is_salt_word or is_gliner_salt) and "active pharmaceutical ingredient" not in overlap_labels:
-            if not _has_neighboring_active(ent.start, ent.end, gliner_entities):
-                cand["_rejected"] = True
-                cand["_rejection_reason"] = "Standalone salt or counter-ion"
-                continue
-                
-        accepted.append(cand)
-        
-    return accepted
-
-def adjudicate(
-    mode: str,
-    pharm_candidates: List[Dict[str, Any]], 
-    gliner_entities: List[Any]
-) -> List[Dict[str, Any]]:
-    """Run adjudication based on experiment mode."""
-    if mode == "gliner_filter":
-        return adjudicate_filter(pharm_candidates, gliner_entities)
-    elif mode == "gliner_adjudicated":
-        # gliner_adjudicated combines filter and salt-aware logic
-        filtered = adjudicate_filter(pharm_candidates, gliner_entities)
-        # remove rejected
-        valid = [c for c in filtered if not c.get("_rejected")]
-        return adjudicate_salt(valid, gliner_entities)
-    
-    return pharm_candidates

docker-compose.ci.yml

@@ -0,0 +1,14 @@
+# CI override — use pre-built image, no volume mounts, no nginx.
+# Usage: docker compose -f docker-compose.yml -f docker-compose.ci.yml up -d api
+services:
+  api:
+    image: pillchecker-api:ci
+    entrypoint: ["/app/scripts/ci-startup.sh"]
+    command: ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
+    ports:
+      - "8000:8000"
+    volumes: []
+    environment:
+      - HF_HOME=/app/models
+    restart: "no"
+

docker-compose.yml

@@ -0,0 +1,15 @@
+services:
+  api:
+    build: .
+    ports:
+      - "8000:8000"
+    volumes:
+      - model-cache:/app/models
+    environment:
+      - HF_HOME=/app/models
+      - HF_TOKEN=${HF_TOKEN:-}
+      - API_KEY=${API_KEY}
+    restart: unless-stopped
+
+volumes:
+  model-cache:

docs/infrastructure_hardening.md

@@ -0,0 +1,62 @@
+# PillChecker Infrastructure Hardening Recommendations
+
+Following an assessment of the current CI/CD and Google Cloud Platform (GCP) setup, the following improvements are recommended to enhance security, reliability, and observability.
+
+## 1. IAM Permissions: Principle of Least Privilege
+
+Currently, the `deploy-sa` service account is used for both CI/CD (deployment) and runtime (execution on Cloud Run). It also has project-wide access to all secrets.
+
+### Recommendations:
+
+*   **Separate Service Accounts**: Split `deploy-sa` into two distinct roles:
+    *   **Deployer SA**: Used only by GitHub Actions. Permissions: `roles/run.admin`, `roles/artifactregistry.writer`, `roles/iam.serviceAccountUser` (restricted to the Runner SA).
+    *   **Runner SA**: Used only by the Cloud Run service at runtime. Permissions: `roles/logging.logWriter`, `roles/secretmanager.secretAccessor` (restricted to specific secrets).
+*   **Restrict Secret Access**: Instead of granting `roles/secretmanager.secretAccessor` at the project level, grant it only on the specific secrets the application needs (`API_KEY`, `HF_TOKEN`, `DRUGBANK_DB_REPO`).
+*   **Remove Default Service Account**: Ensure the Default Compute Service Account is not used and has no permissions, as it often has broad `Editor` access by default.
+
+## 2. Cloud Run Reliability: Health Probes
+
+The current Cloud Run configuration uses a basic `tcpSocket` startup probe.
+
+### Recommendations:
+
+*   **Switch to HTTP Probes**: Use `httpGet` probes to `/health` instead of `tcpSocket`. This ensures the application is not just listening on a port but is actually ready to handle requests.
+*   **Add Liveness Probe**: Implement a liveness probe to automatically restart the container if the Python process deadlocks or becomes unresponsive.
+*   **Example Configuration**:
+    ```yaml
+    startupProbe:
+      httpGet:
+        path: /health
+        port: 8000
+      failureThreshold: 5
+      periodSeconds: 10
+    livenessProbe:
+      httpGet:
+        path: /health
+        port: 8000
+      periodSeconds: 30
+    ```
+
+## 3. Observability: Structured Logging
+
+Audit logs are currently generated as JSON strings in `stdout`.
+
+### Recommendations:
+
+*   **Standardize Structured Logging**: Use a logging library (like `structlog` or `google-cloud-logging`) to ensure all logs, not just audit logs, are emitted as structured JSON.
+*   **Cloud Logging Integration**: Ensure `severity` levels (INFO, WARNING, ERROR) are correctly mapped to GCP Cloud Logging levels by including a `"severity"` field in the JSON payload.
+*   **Log Retention**: Ensure audit logs are retained for a period sufficient for compliance/auditing (e.g., 365 days), potentially exporting them to BigQuery for long-term analysis.
+
+## 4. Container Optimization (Completed)
+
+We have already improved the container security and efficiency by:
+*   Switching to a **non-root user** (`pillchecker`) in the `Dockerfile`.
+*   Replacing the Node.js-based MCP server with **direct SQLite integration**, which:
+    *   Reduced the image size (no Node.js runtime or binaries).
+    *   Eliminated child process management overhead and latency.
+    *   Removed Node-specific security vulnerabilities from the attack surface.
+
+## 5. Network Security
+
+*   **Ingress Control**: If the API is only intended for use by a specific frontend or mobile app, consider restricting ingress to `Internal and Cloud Load Balancing` and placing a Cloud Armor policy in front of it.
+*   **Egress Control**: If the application only needs to talk to specific external APIs (like NLM or HuggingFace), consider using a VPC Service Control or a NAT Gateway with restricted egress rules.

docs/openapi.json

@@ -0,0 +1,351 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "PillChecker API",
+    "description": "Medication interaction checker",
+    "version": "0.1.0"
+  },
+  "paths": {
+    "/health": {
+      "get": {
+        "summary": "Health Check",
+        "description": "Basic health check to verify the API is running.",
+        "operationId": "health_check_health_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/health/data": {
+      "get": {
+        "summary": "Data Health Check",
+        "description": "Check the status of the medication interaction database.",
+        "operationId": "data_health_check_health_data_get",
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {}
+              }
+            }
+          }
+        }
+      }
+    },
+    "/analyze": {
+      "post": {
+        "summary": "Analyze",
+        "operationId": "analyze_analyze_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/AnalyzeRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/AnalyzeResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/interactions": {
+      "post": {
+        "summary": "Check Interactions",
+        "operationId": "check_interactions_interactions_post",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/InteractionsRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Successful Response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/InteractionsResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/HTTPValidationError"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "AnalyzeRequest": {
+        "properties": {
+          "text": {
+            "type": "string",
+            "minLength": 1,
+            "title": "Text",
+            "examples": [
+              "BRUFEN Ibuprofen 400 mg Film-Coated Tablets"
+            ]
+          }
+        },
+        "type": "object",
+        "required": [
+          "text"
+        ],
+        "title": "AnalyzeRequest"
+      },
+      "AnalyzeResponse": {
+        "properties": {
+          "drugs": {
+            "items": {
+              "$ref": "#/components/schemas/DrugResult"
+            },
+            "type": "array",
+            "title": "Drugs"
+          },
+          "raw_text": {
+            "type": "string",
+            "title": "Raw Text"
+          }
+        },
+        "type": "object",
+        "required": [
+          "drugs",
+          "raw_text"
+        ],
+        "title": "AnalyzeResponse"
+      },
+      "DrugResult": {
+        "properties": {
+          "rxcui": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Rxcui"
+          },
+          "name": {
+            "type": "string",
+            "title": "Name"
+          },
+          "dosage": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Dosage"
+          },
+          "form": {
+            "anyOf": [
+              {
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ],
+            "title": "Form"
+          },
+          "source": {
+            "type": "string",
+            "title": "Source"
+          },
+          "confidence": {
+            "type": "number",
+            "title": "Confidence"
+          }
+        },
+        "type": "object",
+        "required": [
+          "rxcui",
+          "name",
+          "dosage",
+          "form",
+          "source",
+          "confidence"
+        ],
+        "title": "DrugResult"
+      },
+      "HTTPValidationError": {
+        "properties": {
+          "detail": {
+            "items": {
+              "$ref": "#/components/schemas/ValidationError"
+            },
+            "type": "array",
+            "title": "Detail"
+          }
+        },
+        "type": "object",
+        "title": "HTTPValidationError"
+      },
+      "InteractionResult": {
+        "properties": {
+          "drug_a": {
+            "type": "string",
+            "title": "Drug A"
+          },
+          "drug_b": {
+            "type": "string",
+            "title": "Drug B"
+          },
+          "severity": {
+            "type": "string",
+            "title": "Severity"
+          },
+          "description": {
+            "type": "string",
+            "title": "Description"
+          },
+          "management": {
+            "type": "string",
+            "title": "Management"
+          }
+        },
+        "type": "object",
+        "required": [
+          "drug_a",
+          "drug_b",
+          "severity",
+          "description",
+          "management"
+        ],
+        "title": "InteractionResult"
+      },
+      "InteractionsRequest": {
+        "properties": {
+          "drugs": {
+            "items": {
+              "type": "string"
+            },
+            "type": "array",
+            "minItems": 2,
+            "title": "Drugs",
+            "examples": [
+              [
+                "ibuprofen",
+                "warfarin"
+              ]
+            ]
+          }
+        },
+        "type": "object",
+        "required": [
+          "drugs"
+        ],
+        "title": "InteractionsRequest"
+      },
+      "InteractionsResponse": {
+        "properties": {
+          "interactions": {
+            "items": {
+              "$ref": "#/components/schemas/InteractionResult"
+            },
+            "type": "array",
+            "title": "Interactions"
+          },
+          "safe": {
+            "type": "boolean",
+            "title": "Safe"
+          }
+        },
+        "type": "object",
+        "required": [
+          "interactions",
+          "safe"
+        ],
+        "title": "InteractionsResponse"
+      },
+      "ValidationError": {
+        "properties": {
+          "loc": {
+            "items": {
+              "anyOf": [
+                {
+                  "type": "string"
+                },
+                {
+                  "type": "integer"
+                }
+              ]
+            },
+            "type": "array",
+            "title": "Location"
+          },
+          "msg": {
+            "type": "string",
+            "title": "Message"
+          },
+          "type": {
+            "type": "string",
+            "title": "Error Type"
+          },
+          "input": {
+            "title": "Input"
+          },
+          "ctx": {
+            "type": "object",
+            "title": "Context"
+          }
+        },
+        "type": "object",
+        "required": [
+          "loc",
+          "msg",
+          "type"
+        ],
+        "title": "ValidationError"
+      }
+    }
+  }
+}

pyproject.toml

@@ -14,9 +14,6 @@ dependencies = [
     "aiosqlite>=0.22.1",
 ]
 
-[project.optional-dependencies]
-gliner = ["gliner"]
-
 [[tool.uv.index]]
 name = "pytorch-cpu"
 url = "https://download.pytorch.org/whl/cpu"

tests/test_admin.py

@@ -0,0 +1,40 @@
+"""Tests for admin cache management endpoint."""
+
+import os
+import pytest
+from unittest.mock import patch, MagicMock, AsyncMock
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture
+def client():
+    mock_drugbank = MagicMock()
+    mock_drugbank.connect = AsyncMock()
+    mock_drugbank.close = AsyncMock()
+    mock_drugbank.health_check = AsyncMock(return_value=True)
+    mock_severity = MagicMock()
+    mock_severity.load_model = MagicMock()
+    mock_severity.is_loaded.return_value = True
+
+    with (
+        patch.dict(os.environ, {"API_KEY": "test-key"}),
+        patch("app.main.drugbank_client", mock_drugbank),
+        patch("app.main.severity_classifier", mock_severity),
+        patch("app.main.ner_model"),
+        patch("app.api.health.drugbank_client", mock_drugbank),
+        patch("app.services.interaction_checker.drugbank_client", mock_drugbank),
+        patch("app.services.interaction_checker.severity_classifier", mock_severity),
+    ):
+        from app.main import app
+        yield TestClient(app)
+
+
+class TestAdminCacheClear:
+    def test_clears_cache_with_valid_key(self, client):
+        resp = client.post("/admin/cache/clear", headers={"X-API-Key": "test-key"})
+        assert resp.status_code == 200
+        assert resp.json()["status"] == "ok"
+
+    def test_rejects_without_key(self, client):
+        resp = client.post("/admin/cache/clear")
+        assert resp.status_code == 401

tests/test_api.py

@@ -0,0 +1,198 @@
+"""API endpoint tests.
+
+Tests /interactions and /health endpoints directly.
+/analyze requires the NER model loaded — tested via Docker or manual run.
+"""
+
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture
+def mock_drugbank():
+    """Mock drugbank_client in every module that imports it."""
+    mock = MagicMock()
+    mock.get_interactions = AsyncMock()
+    mock.health_check = AsyncMock(return_value=True)
+    mock.connect = AsyncMock()
+    mock.close = AsyncMock()
+    mock.DrugBankUnavailableError = Exception
+    with patch("app.services.interaction_checker.drugbank_client", mock), \
+         patch("app.api.health.drugbank_client", mock), \
+         patch("app.main.drugbank_client", mock):
+        yield mock
+
+
+@pytest.fixture
+def mock_severity():
+    """Mock severity_classifier in every module that imports it."""
+    mock = MagicMock()
+    mock.classify.return_value = ("moderate", False)
+    mock.load_model = MagicMock()
+    mock.is_loaded.return_value = True
+    with patch("app.services.interaction_checker.severity_classifier", mock), \
+         patch("app.main.severity_classifier", mock):
+        yield mock
+
+
+@pytest.fixture
+def mock_severity_parser():
+    """Mock severity_parser in interaction checker."""
+    mock = MagicMock()
+    mock.parse_severity.return_value = "moderate"
+    with patch("app.services.interaction_checker.severity_parser", mock):
+        yield mock
+
+
+@pytest.fixture
+def client(mock_drugbank, mock_severity, mock_severity_parser):
+    from app.main import app
+    return TestClient(app)
+
+
+class TestAnalyzeValidation:
+    def test_analyze_rejects_oversized_text(self, client):
+        """Text over 5000 chars must be rejected with 422."""
+        resp = client.post(
+            "/analyze",
+            json={"text": "Metformin 500mg " * 500},
+            headers={"X-API-Key": "test-key"},
+        )
+        assert resp.status_code == 422
+
+    def test_analyze_strips_html_from_raw_text(self, client):
+        """HTML tags must be stripped from raw_text to prevent XSS."""
+        with patch("app.services.drug_analyzer.analyze", new=AsyncMock(return_value=[])):
+            resp = client.post(
+                "/analyze",
+                json={"text": '<script>alert(1)</script>Metformin 500mg'},
+                headers={"X-API-Key": "test-key"},
+            )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert "<script>" not in data["raw_text"]
+        assert "alert(1)" in data["raw_text"]
+
+    def test_analyze_non_latin_text_returns_note(self, client):
+        """Non-Latin text should return empty drugs with explanatory note."""
+        resp = client.post(
+            "/analyze",
+            json={"text": "阿莫西林胶囊 500mg"},
+            headers={"X-API-Key": "test-key"},
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["drugs"] == []
+        assert "note" in data
+        assert "Latin" in data["note"]
+
+    def test_analyze_mixed_script_processes_normally(self, client):
+        """Text with mostly Latin chars should process normally even with some non-Latin."""
+        with patch("app.api.analyze.drug_analyzer.analyze", new=AsyncMock(return_value=[])):
+            resp = client.post(
+                "/analyze",
+                json={"text": "Metformin 500mg (メトホルミン)"},
+                headers={"X-API-Key": "test-key"},
+            )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data.get("note") is None or "Non-Latin" not in data.get("note", "")
+
+
+class TestInteractionsValidation:
+    def test_interactions_rejects_empty_string_drug(self, client):
+        """Empty strings in drugs list must be rejected with 422."""
+        resp = client.post(
+            "/interactions",
+            json={"drugs": ["metformin", "", "lisinopril"]},
+            headers={"X-API-Key": "test-key"},
+        )
+        assert resp.status_code == 422
+
+    def test_interactions_rejects_whitespace_only_drug(self, client):
+        """Whitespace-only strings must be rejected after stripping."""
+        resp = client.post(
+            "/interactions",
+            json={"drugs": ["  ", "metformin"]},
+            headers={"X-API-Key": "test-key"},
+        )
+        assert resp.status_code == 422
+
+    def test_interactions_rejects_long_drug_name(self, client):
+        """Drug names over 200 chars must be rejected."""
+        resp = client.post(
+            "/interactions",
+            json={"drugs": ["a" * 201, "metformin"]},
+            headers={"X-API-Key": "test-key"},
+        )
+        assert resp.status_code == 422
+
+
+class TestInteractionsEndpoint:
+    def test_known_interaction(self, client, mock_drugbank):
+        mock_drugbank.get_interactions.side_effect = [
+            [{"drug": "Warfarin", "description": "Increases bleeding risk."}],
+            [{"drug": "Ibuprofen", "description": "Increases bleeding risk."}],
+        ]
+        resp = client.post("/interactions", json={"drugs": ["ibuprofen", "warfarin"]})
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["safe"] is False
+        assert len(data["interactions"]) >= 1
+        assert data["interactions"][0]["severity"] in ["major", "moderate"]
+        assert "data_sources" in data
+        assert "severity_classifier" in data["data_sources"]
+
+    def test_no_interaction(self, client, mock_drugbank):
+        mock_drugbank.get_interactions.side_effect = [
+            [], [],
+        ]
+        resp = client.post("/interactions", json={"drugs": ["ibuprofen", "amoxicillin"]})
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["safe"] is True
+
+    def test_three_drugs(self, client, mock_drugbank):
+        mock_drugbank.get_interactions.side_effect = [
+            [{"drug": "Warfarin", "description": "x"}, {"drug": "Aspirin", "description": "x"}],
+            [{"drug": "Ibuprofen", "description": "x"}, {"drug": "Aspirin", "description": "x"}],
+            [{"drug": "Ibuprofen", "description": "x"}, {"drug": "Warfarin", "description": "x"}],
+        ]
+        resp = client.post("/interactions", json={"drugs": ["ibuprofen", "warfarin", "aspirin"]})
+        assert resp.status_code == 200
+        data = resp.json()
+        assert len(data["interactions"]) >= 2
+
+    def test_validation_requires_two_drugs(self, client):
+        resp = client.post("/interactions", json={"drugs": ["ibuprofen"]})
+        assert resp.status_code == 422
+
+    def test_validation_requires_drugs_field(self, client):
+        resp = client.post("/interactions", json={})
+        assert resp.status_code == 422
+
+
+class TestHealthEndpoint:
+    def test_health_returns_ok(self, client):
+        resp = client.get("/health")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["status"] == "ok"
+        assert data["version"] == "0.1.0"
+
+    def test_data_health_connected(self, client, mock_drugbank):
+        mock_drugbank.health_check.return_value = True
+        resp = client.get("/health/data")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["status"] == "ready"
+        assert data["drugbank"] == "connected"
+
+    def test_data_health_degraded(self, client, mock_drugbank):
+        mock_drugbank.health_check.return_value = False
+        resp = client.get("/health/data")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["status"] == "degraded"
+        assert data["drugbank"] == "unreachable"

tests/test_api_key.py

@@ -0,0 +1,85 @@
+"""Tests for API key middleware."""
+
+import os
+import pytest
+from unittest.mock import patch
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+
+def make_test_app() -> FastAPI:
+    """Minimal app with middleware and stub routes (no NER model needed)."""
+    from app.middleware.api_key import APIKeyMiddleware
+
+    test_app = FastAPI()
+    test_app.add_middleware(APIKeyMiddleware)
+
+    @test_app.get("/health")
+    def health():
+        return {"status": "ok"}
+
+    @test_app.get("/health/data")
+    def health_data():
+        return {"status": "ready"}
+
+    @test_app.post("/analyze")
+    def analyze():
+        return {"drugs": [], "raw_text": "test"}
+
+    @test_app.post("/interactions")
+    def interactions():
+        return {"interactions": [], "safe": True}
+
+    return test_app
+
+
+@pytest.fixture
+def client_with_key():
+    with patch.dict(os.environ, {"API_KEY": "test-secret-key"}):
+        yield TestClient(make_test_app())
+
+
+@pytest.fixture
+def client_without_key():
+    env = {k: v for k, v in os.environ.items() if k != "API_KEY"}
+    with patch.dict(os.environ, env, clear=True):
+        yield TestClient(make_test_app())
+
+
+class TestAPIKeyMiddleware:
+    def test_health_no_key_required(self, client_with_key):
+        r = client_with_key.get("/health")
+        assert r.status_code == 200
+
+    def test_health_data_no_key_required(self, client_with_key):
+        r = client_with_key.get("/health/data")
+        assert r.status_code == 200
+
+    def test_analyze_rejected_without_key(self, client_with_key):
+        r = client_with_key.post("/analyze", json={"text": "ibuprofen"})
+        assert r.status_code == 401
+
+    def test_analyze_rejected_with_wrong_key(self, client_with_key):
+        r = client_with_key.post(
+            "/analyze",
+            json={"text": "ibuprofen"},
+            headers={"X-API-Key": "wrong"},
+        )
+        assert r.status_code == 401
+
+    def test_analyze_accepted_with_correct_key(self, client_with_key):
+        r = client_with_key.post(
+            "/analyze",
+            json={"text": "ibuprofen"},
+            headers={"X-API-Key": "test-secret-key"},
+        )
+        assert r.status_code == 200
+
+    def test_interactions_rejected_without_key(self, client_with_key):
+        r = client_with_key.post("/interactions", json={"drugs": ["a", "b"]})
+        assert r.status_code == 401
+
+    def test_no_api_key_env_disables_auth(self, client_without_key):
+        r = client_without_key.post("/analyze", json={"text": "ibuprofen"})
+        # Auth is disabled when API_KEY env var is not set
+        assert r.status_code != 401

tests/test_audit_log.py

@@ -0,0 +1,29 @@
+"""Tests for audit logging middleware."""
+
+from app.middleware.audit_log import AuditContext, get_audit_context, init_audit_context
+
+
+class TestAuditContext:
+    def test_init_creates_context(self):
+        ctx = init_audit_context()
+        assert isinstance(ctx, AuditContext)
+        assert ctx.entries == []
+
+    def test_append_entry(self):
+        ctx = init_audit_context()
+        ctx.add("ner", {"entities": ["ibuprofen"]})
+        assert len(ctx.entries) == 1
+        assert ctx.entries[0]["stage"] == "ner"
+
+    def test_get_returns_current_context(self):
+        ctx = init_audit_context()
+        ctx.add("test", {"data": "value"})
+        retrieved = get_audit_context()
+        assert retrieved is ctx
+
+    def test_to_dict(self):
+        ctx = init_audit_context()
+        ctx.add("ner", {"count": 2})
+        result = ctx.to_dict()
+        assert "entries" in result
+        assert "timestamp" in result

tests/test_dosage_parser.py

@@ -0,0 +1,138 @@
+"""Tests for dosage regex parser — 20+ real packaging examples."""
+
+from app.nlp.dosage_parser import Dosage, extract_dosages
+
+
+class TestSimpleDosages:
+    def test_ibuprofen_400mg(self):
+        result = extract_dosages("Ibuprofen 400 mg Film-Coated Tablets")
+        assert len(result) == 1
+        assert result[0].value == 400.0
+        assert result[0].unit == "mg"
+
+    def test_paracetamol_500mg_no_space(self):
+        result = extract_dosages("Paracetamol 500mg tablets")
+        assert len(result) == 1
+        assert result[0].value == 500.0
+
+    def test_vitamin_d_1000iu(self):
+        result = extract_dosages("Vitamin D3 1000 IU capsules")
+        assert len(result) == 1
+        assert result[0].unit == "IU"
+
+    def test_levothyroxine_50mcg(self):
+        result = extract_dosages("Levothyroxine 50 mcg tablets")
+        assert len(result) == 1
+        assert result[0].value == 50.0
+        assert result[0].unit == "mcg"
+
+    def test_metformin_850mg(self):
+        result = extract_dosages("Metformin HCl 850 mg")
+        assert len(result) == 1
+        assert result[0].value == 850.0
+
+    def test_decimal_dosage(self):
+        result = extract_dosages("Alprazolam 0.5 mg tablets")
+        assert len(result) == 1
+        assert result[0].value == 0.5
+
+    def test_amoxicillin_1g(self):
+        result = extract_dosages("Amoxicillin 1 g powder")
+        assert len(result) == 1
+        assert result[0].unit == "g"
+
+    def test_microgram_symbol(self):
+        result = extract_dosages("Fentanyl 25 µg/hr patch")
+        dosage = [d for d in result if d.unit == "µg"]
+        assert len(dosage) >= 1
+        assert dosage[0].value == 25.0
+
+
+class TestCompoundDosages:
+    def test_suspension_10mg_5ml(self):
+        result = extract_dosages("Ibuprofen 10 mg/5 ml oral suspension")
+        compound = [d for d in result if d.per_value is not None]
+        assert len(compound) >= 1
+        assert compound[0].value == 10.0
+        assert compound[0].per_value == 5.0
+        assert compound[0].per_unit == "ml"
+
+    def test_concentration_500mg_5ml(self):
+        result = extract_dosages("Amoxicillin 500mg/5ml")
+        compound = [d for d in result if d.per_value is not None]
+        assert len(compound) >= 1
+        assert compound[0].value == 500.0
+
+    def test_per_ml(self):
+        result = extract_dosages("Insulin 100 IU/ml")
+        compound = [d for d in result if d.per_unit is not None]
+        assert len(compound) >= 1
+        assert compound[0].unit == "IU"
+
+    def test_solution_200mg_ml(self):
+        result = extract_dosages("Ibuprofen 200mg/ml drops")
+        compound = [d for d in result if d.per_unit is not None]
+        assert len(compound) >= 1
+
+
+class TestPerUnitDosages:
+    def test_per_tablet(self):
+        result = extract_dosages("500 mg/tablet")
+        per_unit = [d for d in result if d.per_unit == "tablet"]
+        assert len(per_unit) >= 1
+        assert per_unit[0].value == 500.0
+
+    def test_per_capsule(self):
+        result = extract_dosages("200 mg/capsule")
+        per_unit = [d for d in result if d.per_unit == "capsule"]
+        assert len(per_unit) >= 1
+
+    def test_per_dose(self):
+        result = extract_dosages("Salbutamol 100 mcg/dose inhaler")
+        per_unit = [d for d in result if d.per_unit == "dose"]
+        assert len(per_unit) >= 1
+        assert per_unit[0].value == 100.0
+
+
+class TestPercentage:
+    def test_cream_1_percent(self):
+        result = extract_dosages("Hydrocortisone 1% cream")
+        assert any(d.unit == "%" and d.value == 1.0 for d in result)
+
+    def test_decimal_percent(self):
+        result = extract_dosages("Betamethasone 0.1% ointment")
+        assert any(d.unit == "%" and d.value == 0.1 for d in result)
+
+
+class TestMultipleDosages:
+    def test_combination_drug(self):
+        # Co-amoxiclav: two active ingredients
+        result = extract_dosages("Amoxicillin 500 mg / Clavulanic Acid 125 mg")
+        mg_dosages = [d for d in result if d.unit == "mg"]
+        assert len(mg_dosages) >= 2
+
+    def test_real_packaging_brufen(self):
+        text = "BRUFEN Ibuprofen 400 mg Film-Coated Tablets"
+        result = extract_dosages(text)
+        assert len(result) >= 1
+        assert result[0].value == 400.0
+
+
+class TestDosagePosition:
+    def test_dosage_includes_start_position(self):
+        """Dosage objects must include the character offset where they appear."""
+        dosages = extract_dosages("Lisinopril 10mg daily, Metformin 500mg")
+        assert len(dosages) == 2
+        assert dosages[0].start == 11   # "10mg" starts at char 11
+        assert dosages[1].start == 33   # "500mg" starts at char 33
+
+
+class TestEdgeCases:
+    def test_no_dosage(self):
+        result = extract_dosages("Take with food and water")
+        assert result == []
+
+    def test_mmol(self):
+        result = extract_dosages("Potassium chloride 10 mmol effervescent")
+        assert len(result) == 1
+        assert result[0].unit == "mmol"

tests/test_drug_analyzer.py

@@ -0,0 +1,382 @@
+"""Unit tests for drug_analyzer — mocks RxNorm client and NER model.
+
+Covers the fallback path quality filters:
+  - Low-score approximate matches must be rejected
+  - Empty drug names must be filtered out
+  - High-confidence matches must still pass through
+"""
+
+import pytest
+from unittest.mock import AsyncMock, patch, MagicMock
+
+from app.clients.rxnorm_client import DrugInfo
+from app.services import drug_analyzer
+from app.nlp import ner_model
+
+
+def _no_ner(text):
+    """Stub NER predict that always returns no drug entities."""
+    return []
+
+
+# ─── Fixtures ────────────────────────────────────────────────────────────────
+
+
+@pytest.fixture(autouse=True)
+def mock_ner():
+    """Patch NER so tests don't require the model to be loaded."""
+    with patch("app.services.drug_analyzer.ner_model.predict", side_effect=_no_ner):
+        yield
+
+
+# ─── Score threshold tests ────────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_low_score_candidate_rejected():
+    """A candidate with score < threshold must not appear in results."""
+    low_score_candidate = DrugInfo(rxcui="2388160", name="Hello Bello", score=3.98)
+
+    with patch(
+        "app.services.drug_analyzer.rxnorm_client.approximate_term",
+        new=AsyncMock(return_value=[low_score_candidate]),
+    ):
+        results = await drug_analyzer.analyze("hello world")
+
+    assert results == [], (
+        f"Expected no results for low-score match, got: {results}"
+    )
+
+
+@pytest.mark.asyncio
+async def test_rxnorm_fallback_rejects_low_score_match():
+    """RxNorm matches with score < 10.0 must be rejected to prevent false positives."""
+    weak_candidate = DrugInfo(rxcui="1490058", name="Take Action", score=8.9)
+
+    with (
+        patch("app.services.drug_analyzer.ner_model.predict", return_value=[]),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.approximate_term",
+            new=AsyncMock(return_value=[weak_candidate]),
+        ),
+    ):
+        results = await drug_analyzer.analyze("Take 1 tablet twice daily")
+
+    assert results == [], f"Expected empty results for low-score match, got: {results}"
+
+
+@pytest.mark.asyncio
+async def test_high_score_candidate_accepted():
+    """A candidate with score >= threshold and a valid name must be returned."""
+    high_score_candidate = DrugInfo(rxcui="5640", name="Ibuprofen", score=10.55)
+
+    with (
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.approximate_term",
+            new=AsyncMock(return_value=[high_score_candidate]),
+        ),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_drug_details",
+            new=AsyncMock(return_value={"name": "ibuprofen"}),
+        ),
+    ):
+        results = await drug_analyzer.analyze("ibuprofen")
+
+    assert len(results) == 1
+    assert results[0]["name"] == "ibuprofen"
+    assert results[0]["source"] == "rxnorm_fallback"
+    assert results[0]["rxcui"] == "5640"
+
+
+# ─── Empty name filter tests ──────────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_empty_name_candidate_rejected():
+    """A candidate with empty name (MMSL source) and empty details must be skipped."""
+    nameless_candidate = DrugInfo(rxcui="2388160", name="", score=11.0)
+
+    with (
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.approximate_term",
+            new=AsyncMock(return_value=[nameless_candidate]),
+        ),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_drug_details",
+            new=AsyncMock(return_value={}),
+        ),
+    ):
+        results = await drug_analyzer.analyze("some text")
+
+    assert results == [], (
+        f"Expected no results when resolved name is empty, got: {results}"
+    )
+
+
+@pytest.mark.asyncio
+async def test_empty_best_name_resolved_from_details():
+    """When candidate name is empty but details has a name, use the details name."""
+    nameless_candidate = DrugInfo(rxcui="5640", name="", score=11.0)
+
+    with (
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.approximate_term",
+            new=AsyncMock(return_value=[nameless_candidate]),
+        ),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_drug_details",
+            new=AsyncMock(return_value={"name": "ibuprofen"}),
+        ),
+    ):
+        results = await drug_analyzer.analyze("ibuprofen 400mg")
+
+    assert len(results) == 1
+    assert results[0]["name"] == "ibuprofen"
+
+
+# ─── No candidates ─────────────────────────────────────────��─────────────────
+
+
+@pytest.mark.asyncio
+async def test_no_candidates_returns_empty():
+    """When RxNorm returns no candidates for any word, result is empty list."""
+    with patch(
+        "app.services.drug_analyzer.rxnorm_client.approximate_term",
+        new=AsyncMock(return_value=[]),
+    ):
+        results = await drug_analyzer.analyze("xyzzy nonsense zzz")
+
+    assert results == []
+
+
+# ─── NER entity filtering tests ───────────────────────────────────────────────
+
+@pytest.mark.asyncio
+async def test_ner_entity_without_rxcui_filtered_out():
+    """NER entities that don't match any RxNorm drug must be excluded."""
+    fake_entity = ner_model.Entity(
+        text="Pactavis", label="CHEM", score=0.85, start=0, end=8,
+    )
+
+    with (
+        patch(
+            "app.services.drug_analyzer.ner_model.predict",
+            return_value=[fake_entity],
+        ),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_rxcui",
+            new=AsyncMock(return_value=None),
+        ),
+        # Fallback should also find nothing
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.approximate_term",
+            new=AsyncMock(return_value=[]),
+        ),
+    ):
+        results = await drug_analyzer.analyze("Pactavis 6 tablets")
+
+    assert results == [], (
+        f"Expected no results for NER entity without RxCUI, got: {results}"
+    )
+
+
+@pytest.mark.asyncio
+async def test_ner_entity_with_rxcui_returned():
+    """NER entities that match a RxNorm drug must be returned."""
+    entity = ner_model.Entity(
+        text="Paracetamol", label="CHEM", score=0.95, start=0, end=11,
+    )
+
+    with (
+        patch(
+            "app.services.drug_analyzer.ner_model.predict",
+            return_value=[entity],
+        ),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_rxcui",
+            new=AsyncMock(return_value="161"),
+        ),
+    ):
+        results = await drug_analyzer.analyze("Paracetamol 500mg")
+
+    assert len(results) == 1
+    assert results[0]["name"] == "Paracetamol"
+    assert results[0]["rxcui"] == "161"
+    assert results[0]["source"] == "ner"
+
+
+@pytest.mark.asyncio
+async def test_all_ner_filtered_falls_through_to_fallback():
+    """When all NER entities lack rxcui, fallback path should be used."""
+    fake_entity = ner_model.Entity(
+        text="Pactavis", label="CHEM", score=0.85, start=0, end=8,
+    )
+    fallback_candidate = DrugInfo(rxcui="10689", name="Trimethoprim", score=10.5)
+
+    with (
+        patch(
+            "app.services.drug_analyzer.ner_model.predict",
+            return_value=[fake_entity],
+        ),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_rxcui",
+            new=AsyncMock(return_value=None),
+        ),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.approximate_term",
+            new=AsyncMock(return_value=[fallback_candidate]),
+        ),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_drug_details",
+            new=AsyncMock(return_value={"name": "trimethoprim"}),
+        ),
+    ):
+        results = await drug_analyzer.analyze("Pactavis Trimethoprim Tablets")
+
+    assert len(results) == 1
+    assert results[0]["name"] == "trimethoprim"
+    assert results[0]["source"] == "rxnorm_fallback"
+
+
+@pytest.mark.asyncio
+async def test_rxnorm_fallback_sets_needs_confirmation():
+    """RxNorm fallback results should have needs_confirmation=True."""
+    candidate = DrugInfo(rxcui="5640", name="Ibuprofen", score=10.55)
+
+    with (
+        patch("app.services.drug_analyzer.rxnorm_client.approximate_term",
+              new=AsyncMock(return_value=[candidate])),
+        patch("app.services.drug_analyzer.rxnorm_client.get_drug_details",
+              new=AsyncMock(return_value={"name": "ibuprofen"})),
+    ):
+        results = await drug_analyzer.analyze("ibuprofen")
+
+    assert results[0]["needs_confirmation"] is True
+    assert results[0]["source"] == "rxnorm_fallback"
+
+
+@pytest.mark.asyncio
+async def test_high_confidence_ner_no_confirmation():
+    """High-confidence NER results should not need confirmation."""
+    entity = ner_model.Entity(text="Ibuprofen", label="CHEM", score=0.95, start=0, end=9)
+
+    with (
+        patch("app.services.drug_analyzer.ner_model.predict", return_value=[entity]),
+        patch("app.services.drug_analyzer.rxnorm_client.get_rxcui",
+              new=AsyncMock(return_value="5640")),
+    ):
+        results = await drug_analyzer.analyze("Ibuprofen 400mg")
+
+    assert results[0]["needs_confirmation"] is False
+
+
+@pytest.mark.asyncio
+async def test_multi_drug_dosages_assigned_by_position():
+    """Each drug should get the dosage nearest to it, not the first found."""
+    entities = [
+        ner_model.Entity(text="Lisinopril", label="CHEM", score=0.93, start=0, end=10),
+        ner_model.Entity(text="Metformin", label="CHEM", score=0.92, start=22, end=31),
+    ]
+
+    async def mock_get_rxcui(name):
+        return {"Lisinopril": "29046", "Metformin": "6809"}.get(name)
+
+    with (
+        patch("app.services.drug_analyzer.ner_model.predict", return_value=entities),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_rxcui",
+            new=AsyncMock(side_effect=mock_get_rxcui),
+        ),
+    ):
+        results = await drug_analyzer.analyze("Lisinopril 10mg daily, Metformin 500mg")
+
+    assert len(results) == 2
+    lisinopril = next(r for r in results if r["name"] == "Lisinopril")
+    metformin = next(r for r in results if r["name"] == "Metformin")
+    assert lisinopril["dosage"] == "10mg"
+    assert metformin["dosage"] == "500mg"
+
+
+@pytest.mark.asyncio
+async def test_low_confidence_ner_needs_confirmation():
+    """NER results with confidence < 0.85 should need confirmation."""
+    entity = ner_model.Entity(text="Paracetamol", label="CHEM", score=0.72, start=0, end=11)
+
+    with (
+        patch("app.services.drug_analyzer.ner_model.predict", return_value=[entity]),
+        patch("app.services.drug_analyzer.rxnorm_client.get_rxcui",
+              new=AsyncMock(return_value="161")),
+    ):
+        results = await drug_analyzer.analyze("Paracetamol 500mg")
+
+    assert results[0]["needs_confirmation"] is True
+
+
+@pytest.mark.asyncio
+async def test_single_char_ner_entity_filtered():
+    """Single-character NER entities (e.g. '-') must be filtered out."""
+    entities = [
+        ner_model.Entity(text="-", label="CHEM", score=0.95, start=0, end=1),
+        ner_model.Entity(text="Metformin", label="CHEM", score=0.93, start=5, end=14),
+    ]
+
+    with (
+        patch("app.services.drug_analyzer.ner_model.predict", return_value=entities),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_rxcui",
+            new=AsyncMock(return_value="6809"),
+        ),
+    ):
+        results = await drug_analyzer.analyze("- Metformin 500mg")
+
+    assert len(results) == 1
+    assert results[0]["name"] == "Metformin"
+
+
+@pytest.mark.asyncio
+async def test_punctuation_only_ner_entity_filtered():
+    """Entities that are pure punctuation must be filtered out."""
+    entities = [
+        ner_model.Entity(text="...", label="CHEM", score=0.90, start=0, end=3),
+        ner_model.Entity(text="Lisinopril", label="CHEM", score=0.92, start=5, end=15),
+    ]
+
+    with (
+        patch("app.services.drug_analyzer.ner_model.predict", return_value=entities),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_rxcui",
+            new=AsyncMock(return_value="29046"),
+        ),
+    ):
+        results = await drug_analyzer.analyze("... Lisinopril 10mg")
+
+    assert len(results) == 1
+    assert results[0]["name"] == "Lisinopril"
+
+
+@pytest.mark.asyncio
+async def test_ner_results_sorted_by_confidence_descending():
+    """Results must be sorted by confidence, highest first."""
+    entities = [
+        ner_model.Entity(text="Aspirin", label="CHEM", score=0.70, start=0, end=7),
+        ner_model.Entity(text="Ibuprofen", label="CHEM", score=0.95, start=20, end=29),
+    ]
+
+    async def mock_get_rxcui(name):
+        return {"Aspirin": "1191", "Ibuprofen": "5640"}.get(name)
+
+    with (
+        patch(
+            "app.services.drug_analyzer.ner_model.predict",
+            return_value=entities,
+        ),
+        patch(
+            "app.services.drug_analyzer.rxnorm_client.get_rxcui",
+            new=AsyncMock(side_effect=mock_get_rxcui),
+        ),
+    ):
+        results = await drug_analyzer.analyze("Aspirin tablets plus Ibuprofen")
+
+    assert len(results) == 2
+    assert results[0]["name"] == "Ibuprofen", "Highest confidence drug should be first"
+    assert results[1]["name"] == "Aspirin"

tests/test_drugbank_client.py

@@ -0,0 +1,192 @@
+"""Tests for the DrugBank client (direct SQLite version)."""
+
+import time
+import pytest
+from unittest.mock import AsyncMock, patch
+from app.clients import drugbank_client
+
+
+class TestResolveId:
+    """Test the internal name → drugbank_id resolution."""
+
+    @pytest.fixture(autouse=True)
+    def reset_cache(self):
+        drugbank_client._cache.clear()
+        yield
+        drugbank_client._cache.clear()
+
+    @pytest.fixture
+    def mock_db(self):
+        with patch("app.clients.drugbank_client.db", new_callable=AsyncMock) as mock:
+            yield mock
+
+    async def test_resolves_name_to_drugbank_id(self, mock_db):
+        mock_db.search_by_name.return_value = [{"drugbank_id": "DB01050", "name": "Ibuprofen"}]
+        result = await drugbank_client._resolve_drugbank_id("ibuprofen")
+        assert result == "DB01050"
+        mock_db.search_by_name.assert_called_once_with("ibuprofen", limit=1)
+
+    async def test_returns_none_when_no_results(self, mock_db):
+        mock_db.search_by_name.return_value = []
+        result = await drugbank_client._resolve_drugbank_id("notadrug")
+        assert result is None
+
+    async def test_caches_resolved_id(self, mock_db):
+        mock_db.search_by_name.return_value = [{"drugbank_id": "DB01050", "name": "Ibuprofen"}]
+        await drugbank_client._resolve_drugbank_id("ibuprofen")
+        await drugbank_client._resolve_drugbank_id("ibuprofen")
+        assert mock_db.search_by_name.call_count == 1
+
+    async def test_caches_none_for_unknown_drugs(self, mock_db):
+        """Unknown drugs (None result) must also be cached."""
+        mock_db.search_by_name.return_value = []
+        await drugbank_client._resolve_drugbank_id("notadrug")
+        await drugbank_client._resolve_drugbank_id("notadrug")
+        assert mock_db.search_by_name.call_count == 1
+
+
+class TestGetInteractions:
+    @pytest.fixture(autouse=True)
+    def reset_cache(self):
+        drugbank_client._cache.clear()
+        yield
+        drugbank_client._cache.clear()
+
+    @pytest.fixture
+    def mock_db(self):
+        with patch("app.clients.drugbank_client.db", new_callable=AsyncMock) as mock:
+            yield mock
+
+    async def test_returns_interactions(self, mock_db):
+        """Full flow: resolve name → fetch interactions → return [{drug, description}]."""
+        mock_db.search_by_name.return_value = [{"drugbank_id": "DB01050", "name": "Ibuprofen"}]
+        mock_db.get_drug_interactions.return_value = [
+            {"name": "Warfarin", "description": "Increases bleeding risk.", "severity": "major"}
+        ]
+        
+        result = await drugbank_client.get_interactions("ibuprofen")
+        assert len(result) == 1
+        assert result[0]["drug"] == "Warfarin"
+        assert result[0]["description"] == "Increases bleeding risk."
+        assert result[0]["severity"] == "major"
+
+    async def test_returns_empty_when_drug_not_found(self, mock_db):
+        mock_db.search_by_name.return_value = []
+        result = await drugbank_client.get_interactions("notadrug")
+        assert result == []
+
+    async def test_returns_empty_for_no_interactions(self, mock_db):
+        mock_db.search_by_name.return_value = [{"drugbank_id": "DB00001", "name": "SomeDrug"}]
+        mock_db.get_drug_interactions.return_value = []
+        result = await drugbank_client.get_interactions("somedrug")
+        assert result == []
+
+    async def test_caches_full_interaction_results(self, mock_db):
+        mock_db.search_by_name.return_value = [{"drugbank_id": "DB01050", "name": "Ibuprofen"}]
+        mock_db.get_drug_interactions.return_value = []
+        
+        await drugbank_client.get_interactions("ibuprofen")
+        await drugbank_client.get_interactions("ibuprofen")
+        # Only 2 calls total (resolve + interactions), not 4
+        assert mock_db.search_by_name.call_count == 1
+        assert mock_db.get_drug_interactions.call_count == 1
+
+    async def test_cache_expires(self, mock_db):
+        mock_db.search_by_name.return_value = [{"drugbank_id": "DB01050", "name": "Ibuprofen"}]
+        mock_db.get_drug_interactions.return_value = []
+        
+        await drugbank_client.get_interactions("ibuprofen")
+        # Expire all cache entries
+        for key in drugbank_client._cache:
+            drugbank_client._cache[key] = (drugbank_client._cache[key][0], time.time() - 1)
+        
+        await drugbank_client.get_interactions("ibuprofen")
+        assert mock_db.search_by_name.call_count == 2
+        assert mock_db.get_drug_interactions.call_count == 2
+
+
+class TestConnect:
+    async def test_connect_calls_db_connect(self):
+        with patch("app.clients.drugbank_client.db", new_callable=AsyncMock) as mock_db:
+            await drugbank_client.connect()
+            mock_db.connect.assert_called_once()
+
+    async def test_connect_handles_failure(self):
+        with patch("app.clients.drugbank_client.db", new_callable=AsyncMock) as mock_db:
+            mock_db.connect.side_effect = Exception("DB error")
+            # Should not raise
+            await drugbank_client.connect()
+
+
+class TestHealthCheck:
+    async def test_health_check_delegates_to_db(self):
+        with patch("app.clients.drugbank_client.db", new_callable=AsyncMock) as mock_db:
+            mock_db.health_check.return_value = True
+            assert await drugbank_client.health_check() is True
+            mock_db.health_check.assert_called_once()
+
+    async def test_health_check_returns_false_when_db_unhealthy(self):
+        with patch("app.clients.drugbank_client.db", new_callable=AsyncMock) as mock_db:
+            mock_db.health_check.return_value = False
+            assert await drugbank_client.health_check() is False
+
+
+class TestErrorPropagation:
+    """Database errors must propagate so transient failures are not cached."""
+
+    @pytest.fixture(autouse=True)
+    def reset_cache(self):
+        drugbank_client._cache.clear()
+        yield
+        drugbank_client._cache.clear()
+
+    @pytest.fixture
+    def mock_db(self):
+        with patch("app.clients.drugbank_client.db", new_callable=AsyncMock) as mock:
+            yield mock
+
+    async def test_resolve_raises_on_db_error(self, mock_db):
+        mock_db.search_by_name.side_effect = RuntimeError("disk I/O error")
+        with pytest.raises(drugbank_client.DrugBankUnavailableError):
+            await drugbank_client._resolve_drugbank_id("ibuprofen")
+
+    async def test_resolve_does_not_cache_db_error(self, mock_db):
+        """A transient DB error must not be cached as 'not found'."""
+        mock_db.search_by_name.side_effect = [
+            RuntimeError("disk I/O error"),
+            [{"drugbank_id": "DB01050", "name": "Ibuprofen"}],
+        ]
+        with pytest.raises(drugbank_client.DrugBankUnavailableError):
+            await drugbank_client._resolve_drugbank_id("ibuprofen")
+        # Next call after DB recovers must hit the DB again and succeed
+        result = await drugbank_client._resolve_drugbank_id("ibuprofen")
+        assert result == "DB01050"
+        assert mock_db.search_by_name.call_count == 2
+
+    async def test_get_interactions_raises_on_resolve_error(self, mock_db):
+        mock_db.search_by_name.side_effect = RuntimeError("disk I/O error")
+        with pytest.raises(drugbank_client.DrugBankUnavailableError):
+            await drugbank_client.get_interactions("ibuprofen")
+
+    async def test_get_interactions_raises_on_lookup_error(self, mock_db):
+        mock_db.search_by_name.return_value = [
+            {"drugbank_id": "DB01050", "name": "Ibuprofen"}
+        ]
+        mock_db.get_drug_interactions.side_effect = RuntimeError("disk I/O error")
+        with pytest.raises(drugbank_client.DrugBankUnavailableError):
+            await drugbank_client.get_interactions("ibuprofen")
+
+    async def test_get_interactions_does_not_cache_db_error(self, mock_db):
+        mock_db.search_by_name.return_value = [
+            {"drugbank_id": "DB01050", "name": "Ibuprofen"}
+        ]
+        mock_db.get_drug_interactions.side_effect = [
+            RuntimeError("disk I/O error"),
+            [{"name": "Warfarin", "description": "x", "severity": "major"}],
+        ]
+        with pytest.raises(drugbank_client.DrugBankUnavailableError):
+            await drugbank_client.get_interactions("ibuprofen")
+        # After recovery, the next call must hit the DB again and succeed
+        result = await drugbank_client.get_interactions("ibuprofen")
+        assert len(result) == 1
+        assert result[0]["drug"] == "Warfarin"

tests/test_drugbank_db.py

@@ -0,0 +1,195 @@
+"""Tests for the direct SQLite DrugBank client."""
+
+import json
+import os
+import sqlite3
+import tempfile
+
+import pytest
+
+from app.clients.drugbank_db import DrugBankDatabase, _escape_fts5_query
+
+
+@pytest.fixture
+def db_path():
+    """Create a temporary SQLite DB that mirrors the drugbank schema."""
+    fd, path = tempfile.mkstemp(suffix=".db")
+    os.close(fd)
+
+    conn = sqlite3.connect(path)
+    try:
+        conn.executescript(
+            """
+            CREATE TABLE drugs (
+                drugbank_id TEXT PRIMARY KEY,
+                name TEXT,
+                description TEXT,
+                groups TEXT,
+                cas_number TEXT,
+                state TEXT,
+                drug_interactions TEXT
+            );
+            CREATE VIRTUAL TABLE drugs_fts USING fts5(drugbank_id UNINDEXED, name);
+            """
+        )
+        conn.executemany(
+            "INSERT INTO drugs (drugbank_id, name, description, groups, cas_number, state, drug_interactions) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?)",
+            [
+                (
+                    "DB01050",
+                    "Ibuprofen",
+                    "NSAID",
+                    json.dumps(["approved"]),
+                    "15687-27-1",
+                    "solid",
+                    json.dumps(
+                        [
+                            {
+                                "name": "Warfarin",
+                                "description": "Increases bleeding risk.",
+                                "severity": "major",
+                            }
+                        ]
+                    ),
+                ),
+                (
+                    "DB00682",
+                    "Warfarin",
+                    "Anticoagulant",
+                    json.dumps(["approved"]),
+                    "81-81-2",
+                    "solid",
+                    json.dumps(
+                        [
+                            {
+                                "name": "Ibuprofen",
+                                "description": "Bleeding.",
+                                "severity": "major",
+                            }
+                        ]
+                    ),
+                ),
+                (
+                    "DB0NOINT",
+                    "Lonelydrug",
+                    "No interactions recorded",
+                    None,
+                    None,
+                    None,
+                    None,
+                ),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO drugs_fts (drugbank_id, name) VALUES (?, ?)",
+            [
+                ("DB01050", "Ibuprofen"),
+                ("DB00682", "Warfarin"),
+                ("DB0NOINT", "Lonelydrug"),
+            ],
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+    yield path
+    os.remove(path)
+
+
+@pytest.fixture
+async def db(db_path):
+    instance = DrugBankDatabase(db_path=db_path)
+    yield instance
+    await instance.close()
+
+
+class TestConnect:
+    async def test_connect_missing_db_raises(self):
+        instance = DrugBankDatabase(db_path="/nonexistent/path/drugbank.db")
+        with pytest.raises(FileNotFoundError):
+            await instance.connect()
+
+    async def test_connect_is_idempotent(self, db):
+        await db.connect()
+        conn = db._conn
+        await db.connect()
+        # Same connection object -- no leak on repeated calls
+        assert db._conn is conn
+
+
+class TestSearchByName:
+    async def test_finds_existing_drug(self, db):
+        rows = await db.search_by_name("Ibuprofen")
+        assert len(rows) == 1
+        assert rows[0]["drugbank_id"] == "DB01050"
+
+    async def test_returns_empty_for_unknown_drug(self, db):
+        rows = await db.search_by_name("notarealdrug")
+        assert rows == []
+
+    async def test_handles_fts5_special_characters(self, db):
+        """FTS5 has special syntax for `*`, `"`, `:`, `(`, etc.
+
+        The client must escape these rather than passing them directly.
+        """
+        # Without escaping, a bare double-quote would be a parse error.
+        rows = await db.search_by_name('"aspirin"')
+        assert rows == []  # returns empty, not an exception
+
+        # A hyphen is treated as NOT by default; escaping should leave it literal.
+        rows = await db.search_by_name("anti-inflammatory")
+        assert rows == []
+
+
+class TestGetDrugInteractions:
+    async def test_returns_interactions(self, db):
+        rows = await db.get_drug_interactions("DB01050")
+        assert len(rows) == 1
+        assert rows[0]["name"] == "Warfarin"
+        assert rows[0]["severity"] == "major"
+
+    async def test_returns_empty_for_missing_drug(self, db):
+        rows = await db.get_drug_interactions("DBNOPE999")
+        assert rows == []
+
+    async def test_returns_empty_when_drug_has_null_interactions(self, db):
+        rows = await db.get_drug_interactions("DB0NOINT")
+        assert rows == []
+
+
+class TestHealthCheck:
+    async def test_healthy(self, db):
+        assert await db.health_check() is True
+
+    async def test_unhealthy_when_db_missing(self):
+        instance = DrugBankDatabase(db_path="/nonexistent/path/drugbank.db")
+        assert await instance.health_check() is False
+
+    async def test_unhealthy_when_underlying_connection_broken(self, db):
+        await db.connect()
+        # Simulate the connection being closed under us; subsequent queries fail.
+        await db._conn.close()
+        assert await db.health_check() is False
+
+    async def test_failed_health_check_resets_connection(self, db):
+        """A broken connection must be dropped so the next call can reconnect."""
+        await db.connect()
+        await db._conn.close()
+        assert await db.health_check() is False
+        # _conn should be reset so subsequent queries re-establish it.
+        assert db._conn is None
+        # After reset the next query reconnects and succeeds.
+        rows = await db.search_by_name("Ibuprofen")
+        assert len(rows) == 1
+
+
+class TestFTS5Escape:
+    def test_wraps_in_quotes(self):
+        assert _escape_fts5_query("aspirin") == '"aspirin"'
+
+    def test_escapes_internal_quotes(self):
+        assert _escape_fts5_query('say "hi"') == '"say ""hi"""'
+
+    def test_leaves_hyphens_alone_inside_phrase(self):
+        assert _escape_fts5_query("anti-inflammatory") == '"anti-inflammatory"'

tests/test_interaction_checker.py

@@ -0,0 +1,238 @@
+"""Tests for the interaction checker service."""
+
+import pytest
+from unittest.mock import AsyncMock, patch
+from app.clients.drugbank_client import DrugBankUnavailableError
+from app.nlp import severity_parser
+from app.services import interaction_checker
+
+
+@pytest.fixture(autouse=True)
+def mock_drugbank():
+    """Mock drugbank_client.get_interactions for all tests."""
+    with patch("app.services.interaction_checker.drugbank_client") as mock:
+        mock.get_interactions = AsyncMock()
+        mock.DrugBankUnavailableError = DrugBankUnavailableError
+        yield mock
+
+
+@pytest.fixture(autouse=True)
+def mock_severity():
+    """Mock severity_classifier.classify for all tests."""
+    with patch("app.services.interaction_checker.severity_classifier") as mock:
+        mock.classify.return_value = ("moderate", False)
+        yield mock
+
+
+@pytest.fixture(autouse=True)
+def mock_severity_parser():
+    """Mock severity_parser.parse_severity for all tests."""
+    with patch("app.services.interaction_checker.severity_parser") as mock:
+        mock.parse_severity.return_value = "moderate"
+        yield mock
+
+
+class TestInteractionChecker:
+    async def test_two_interacting_drugs(self, mock_drugbank, mock_severity):
+        mock_drugbank.get_interactions.side_effect = [
+            [{"drug": "Warfarin", "description": "Increases bleeding risk."}],
+            [{"drug": "Ibuprofen", "description": "Increases bleeding risk."}],
+        ]
+        result = await interaction_checker.check(["ibuprofen", "warfarin"])
+        assert result["safe"] is False
+        assert len(result["interactions"]) == 1
+        assert result["interactions"][0]["drug_a"] == "ibuprofen"
+        assert result["interactions"][0]["drug_b"] == "warfarin"
+        assert result["interactions"][0]["severity"] == "moderate"
+        assert result["interactions"][0]["description"] == "Increases bleeding risk."
+        assert result["error"] is None
+
+    async def test_two_safe_drugs(self, mock_drugbank):
+        mock_drugbank.get_interactions.side_effect = [
+            [{"drug": "Metformin", "description": "some interaction"}],
+            [{"drug": "Lisinopril", "description": "some interaction"}],
+        ]
+        result = await interaction_checker.check(["ibuprofen", "amoxicillin"])
+        assert result["safe"] is True
+        assert result["interactions"] == []
+
+    async def test_three_drugs_multiple_interactions(self, mock_drugbank):
+        mock_drugbank.get_interactions.side_effect = [
+            [{"drug": "Warfarin", "description": "bleeding"}, {"drug": "Aspirin", "description": "bleeding"}],
+            [{"drug": "Ibuprofen", "description": "bleeding"}, {"drug": "Aspirin", "description": "bleeding"}],
+            [{"drug": "Ibuprofen", "description": "bleeding"}, {"drug": "Warfarin", "description": "bleeding"}],
+        ]
+        result = await interaction_checker.check(["ibuprofen", "warfarin", "aspirin"])
+        assert result["safe"] is False
+        assert len(result["interactions"]) == 3
+
+    async def test_single_drug(self, mock_drugbank):
+        result = await interaction_checker.check(["ibuprofen"])
+        assert result["safe"] is True
+
+    async def test_empty_list(self, mock_drugbank):
+        result = await interaction_checker.check([])
+        assert result["safe"] is True
+
+    async def test_drugbank_unavailable(self, mock_drugbank):
+        mock_drugbank.get_interactions.side_effect = DrugBankUnavailableError("down")
+        result = await interaction_checker.check(["ibuprofen", "warfarin"])
+        assert result["safe"] is None
+        assert result["error"] == "Drug interaction data temporarily unavailable"
+        assert result["interactions"] == []
+
+    async def test_case_insensitive_matching(self, mock_drugbank):
+        mock_drugbank.get_interactions.side_effect = [
+            [{"drug": "WARFARIN", "description": "bleeding risk"}],
+            [{"drug": "ibuprofen", "description": "bleeding risk"}],
+        ]
+        result = await interaction_checker.check(["Ibuprofen", "warfarin"])
+        assert result["safe"] is False
+        assert len(result["interactions"]) == 1
+
+    async def test_partial_drugbank_failure_still_checks_available_pairs(self, mock_drugbank, mock_severity):
+        """If one drug fails but others succeed, check the available pairs."""
+        mock_drugbank.get_interactions.side_effect = [
+            DrugBankUnavailableError("timeout"),  # ibuprofen fails
+            [{"drug": "Aspirin", "description": "bleeding"}],  # warfarin succeeds
+            [{"drug": "Warfarin", "description": "bleeding"}],  # aspirin succeeds
+        ]
+        result = await interaction_checker.check(["ibuprofen", "warfarin", "aspirin"])
+        assert result["safe"] is False
+        assert result["error"] is None
+        # warfarin-aspirin pair should still be found
+        assert len(result["interactions"]) >= 1
+        pairs = [(i["drug_a"], i["drug_b"]) for i in result["interactions"]]
+        assert ("warfarin", "aspirin") in pairs
+
+    async def test_duplicate_drug_names_no_self_interaction(self, mock_drugbank):
+        """Duplicate drug names must not produce self-interaction pairs."""
+        mock_drugbank.get_interactions.side_effect = [
+            [{"drug": "Ibuprofen", "description": "bleeding"}],  # ibuprofen lists itself
+            [{"drug": "Warfarin", "description": "bleeding"}],
+        ]
+        result = await interaction_checker.check(["ibuprofen", "ibuprofen", "warfarin"])
+        # Should check only one pair: ibuprofen-warfarin (no self-pair)
+        for interaction in result["interactions"]:
+            assert interaction["drug_a"] != interaction["drug_b"]
+
+
+@pytest.fixture
+def mock_openfda(mock_drugbank):
+    """Mock openfda_client for interaction checker tests."""
+    with patch("app.services.interaction_checker.openfda_client") as mock:
+        mock.check_pair = AsyncMock(return_value=None)
+        yield mock
+
+
+class TestOpenFDAFallback:
+    async def test_openfda_called_when_both_drugbank_lists_empty(self, mock_drugbank, mock_openfda, mock_severity):
+        """Both drugs return [] from DrugBank → OpenFDA is tried."""
+        mock_drugbank.get_interactions.return_value = []
+        mock_openfda.check_pair.return_value = {
+            "drug": "ibuprofen",
+            "description": "Ibuprofen increases bleeding risk with warfarin.",
+        }
+        result = await interaction_checker.check(["warfarin", "ibuprofen"])
+        assert result["safe"] is False
+        assert len(result["interactions"]) == 1
+        assert result["interactions"][0]["drug_a"] == "warfarin"
+        assert result["interactions"][0]["drug_b"] == "ibuprofen"
+        mock_openfda.check_pair.assert_called()
+
+    async def test_openfda_called_when_one_drugbank_list_empty(self, mock_drugbank, mock_openfda, mock_severity):
+        """Asymmetric case: drug_a empty, drug_b non-empty but no match → OpenFDA fires."""
+        mock_drugbank.get_interactions.side_effect = [
+            [],  # warfarin → empty (cap hit)
+            [{"drug": "aspirin", "description": "bleeding"}],  # ibuprofen → non-empty, no warfarin
+        ]
+        mock_openfda.check_pair.return_value = {
+            "drug": "ibuprofen",
+            "description": "Ibuprofen increases anticoagulant effect.",
+        }
+        result = await interaction_checker.check(["warfarin", "ibuprofen"])
+        assert result["safe"] is False
+        mock_openfda.check_pair.assert_called()
+
+    async def test_openfda_not_called_when_both_drugbank_lists_nonempty(self, mock_drugbank, mock_openfda):
+        """Both drugs have non-empty DrugBank lists → OpenFDA is never called."""
+        mock_drugbank.get_interactions.side_effect = [
+            [{"drug": "metformin", "description": "some"}],
+            [{"drug": "lisinopril", "description": "some"}],
+        ]
+        result = await interaction_checker.check(["warfarin", "ibuprofen"])
+        assert result["safe"] is True
+        mock_openfda.check_pair.assert_not_called()
+
+    async def test_openfda_bidirectional_retry(self, mock_drugbank, mock_openfda, mock_severity):
+        """check_pair(a, b) returns None → check_pair(b, a) is tried."""
+        mock_drugbank.get_interactions.return_value = []
+        # First call (warfarin→ibuprofen) returns None, second (ibuprofen→warfarin) finds match
+        mock_openfda.check_pair.side_effect = [
+            None,
+            {"drug": "warfarin", "description": "Warfarin increases bleeding risk."},
+        ]
+        result = await interaction_checker.check(["warfarin", "ibuprofen"])
+        assert result["safe"] is False
+        assert mock_openfda.check_pair.call_count == 2
+
+    async def test_openfda_finds_nothing_returns_safe(self, mock_drugbank, mock_openfda):
+        """Both DrugBank and OpenFDA miss → safe: true."""
+        mock_drugbank.get_interactions.return_value = []
+        mock_openfda.check_pair.return_value = None
+        result = await interaction_checker.check(["warfarin", "ibuprofen"])
+        assert result["safe"] is True
+        assert result["interactions"] == []
+
+    async def test_openfda_exception_does_not_propagate(self, mock_drugbank, mock_openfda):
+        """OpenFDA raising an exception must not crash the checker."""
+        mock_drugbank.get_interactions.return_value = []
+        mock_openfda.check_pair.side_effect = Exception("OpenFDA down")
+        result = await interaction_checker.check(["warfarin", "ibuprofen"])
+        assert result["safe"] is True
+        assert result["error"] is None
+
+
+class TestSourceRouting:
+    async def test_drugbank_interaction_uses_template_parser(
+        self, mock_drugbank, mock_severity_parser, mock_severity
+    ):
+        """DrugBank interactions should use severity_parser, not classifier."""
+        mock_drugbank.get_interactions.side_effect = [
+            [{"drug": "Warfarin", "description": "The risk or severity of bleeding can be increased."}],
+            [],
+        ]
+        mock_severity_parser.parse_severity.return_value = "major"
+        result = await interaction_checker.check(["ibuprofen", "warfarin"])
+        mock_severity_parser.parse_severity.assert_called_once()
+        mock_severity.classify.assert_not_called()
+        assert result["interactions"][0]["severity"] == "major"
+        assert result["interactions"][0]["uncertain"] is False
+
+    async def test_openfda_interaction_uses_classifier(
+        self, mock_drugbank, mock_openfda, mock_severity_parser, mock_severity
+    ):
+        """OpenFDA fallback interactions should use zero-shot classifier."""
+        mock_drugbank.get_interactions.return_value = []
+        mock_openfda.check_pair.return_value = {
+            "drug": "ibuprofen",
+            "description": "Ibuprofen increases bleeding risk with warfarin.",
+        }
+        mock_severity.classify.return_value = ("major", False)
+        result = await interaction_checker.check(["warfarin", "ibuprofen"])
+        mock_severity.classify.assert_called_once()
+        mock_severity_parser.parse_severity.assert_not_called()
+
+    async def test_drugbank_unknown_template_falls_back_to_classifier(
+        self, mock_drugbank, mock_severity_parser, mock_severity
+    ):
+        """When template parser returns 'unknown', fall back to classifier."""
+        mock_drugbank.get_interactions.side_effect = [
+            [{"drug": "Warfarin", "description": "Novel interaction format."}],
+            [],
+        ]
+        mock_severity_parser.parse_severity.return_value = "unknown"
+        mock_severity.classify.return_value = ("moderate", True)
+        result = await interaction_checker.check(["ibuprofen", "warfarin"])
+        mock_severity.classify.assert_called_once()
+        assert result["interactions"][0]["uncertain"] is True

tests/test_ocr_cleaner.py

@@ -0,0 +1,54 @@
+"""Tests for OCR text preprocessing."""
+
+from app.nlp.ocr_cleaner import clean
+
+
+class TestCharacterSubstitutions:
+    def test_zero_to_o_in_drug_context(self):
+        assert "metformin" in clean("metf0rmin").lower()
+
+    def test_one_to_l(self):
+        assert "alprazolam" in clean("a1prazolam").lower()
+
+    def test_rn_to_m_in_drug_context(self):
+        # "ibuprofen" OCR'd as "ibuprofern" — this is tricky,
+        # only apply when rn could be m in known patterns
+        result = clean("Aceta rninophen")
+        assert "Acetaminophen" in result or "acetaminophen" in result.lower()
+
+
+class TestWhitespaceNormalization:
+    def test_multiple_spaces(self):
+        assert clean("Ibuprofen   400mg") == "Ibuprofen 400mg"
+
+    def test_tabs_and_newlines(self):
+        assert clean("Ibuprofen\t400\nmg") == "Ibuprofen 400 mg"
+
+    def test_soft_hyphens(self):
+        assert clean("Ibu\u00adprofen") == "Ibuprofen"
+
+
+class TestNonAsciiArtifacts:
+    def test_smart_quotes_replaced(self):
+        result = clean("\u201cIbuprofen\u201d")
+        assert '"' not in result or result == '"Ibuprofen"'
+
+    def test_zero_width_chars_stripped(self):
+        result = clean("Ibu\u200bprofen")
+        assert result == "Ibuprofen"
+
+    def test_ligatures_expanded(self):
+        result = clean("\ufb01lm")  # fi ligature
+        assert result == "film"
+
+
+class TestEdgeCases:
+    def test_empty_string(self):
+        assert clean("") == ""
+
+    def test_already_clean_text(self):
+        assert clean("Ibuprofen 400mg Film-Coated Tablets") == "Ibuprofen 400mg Film-Coated Tablets"
+
+    def test_preserves_legitimate_digits(self):
+        """Digits in dosages must not be converted."""
+        assert "400" in clean("Ibuprofen 400mg")

tests/test_openfda_client.py

@@ -0,0 +1,147 @@
+"""Tests for the OpenFDA fallback client."""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+from app.clients import openfda_client
+
+
+@pytest.fixture(autouse=True)
+def reset_cache():
+    openfda_client._cache.clear()
+    yield
+    openfda_client._cache.clear()
+
+
+WARFARIN_LABEL = {
+    "results": [{
+        "drug_interactions": [
+            "Ibuprofen and other NSAIDs may enhance the anticoagulant effect of warfarin.",
+            "Patients should be monitored closely when combining these medications."
+        ]
+    }]
+}
+
+WARFARIN_LABEL_NO_INTERACTIONS = {
+    "results": [{}]
+}
+
+EMPTY_RESULTS = {"results": []}
+
+
+def make_response(json_data, status_code=200):
+    mock = MagicMock()
+    mock.status_code = status_code
+    mock.json.return_value = json_data
+    mock.raise_for_status = MagicMock()
+    if status_code >= 400:
+        mock.raise_for_status.side_effect = Exception(f"HTTP {status_code}")
+    return mock
+
+
+class TestCheckPair:
+    async def test_returns_match_when_drug_mentioned(self):
+        with patch("app.clients.openfda_client._fetch_label_text", new=AsyncMock(
+            return_value="Ibuprofen and other NSAIDs may enhance the anticoagulant effect of warfarin. Patients should monitor closely."
+        )):
+            result = await openfda_client.check_pair("warfarin", "ibuprofen")
+        assert result is not None
+        assert result["drug"] == "ibuprofen"
+        assert "ibuprofen" in result["description"].lower()
+        assert len(result["description"]) > 0
+
+    async def test_returns_none_when_drug_not_mentioned(self):
+        with patch("app.clients.openfda_client._fetch_label_text", new=AsyncMock(
+            return_value="This drug interacts with aspirin and heparin."
+        )):
+            result = await openfda_client.check_pair("warfarin", "ibuprofen")
+        assert result is None
+
+    async def test_returns_none_when_label_unavailable(self):
+        with patch("app.clients.openfda_client._fetch_label_text", new=AsyncMock(return_value=None)):
+            result = await openfda_client.check_pair("unknowndrug", "ibuprofen")
+        assert result is None
+
+    async def test_whole_word_match_only(self):
+        """'aspirin' inside 'heparin' must NOT match."""
+        with patch("app.clients.openfda_client._fetch_label_text", new=AsyncMock(
+            return_value="Use with caution in patients on heparin therapy."
+        )):
+            result = await openfda_client.check_pair("warfarin", "aspirin")
+        assert result is None
+
+    async def test_description_is_never_empty_on_match(self):
+        """check_pair must guarantee non-empty description when it returns a dict."""
+        with patch("app.clients.openfda_client._fetch_label_text", new=AsyncMock(
+            return_value="ibuprofen"  # match with no surrounding sentence context
+        )):
+            result = await openfda_client.check_pair("warfarin", "ibuprofen")
+        assert result is not None
+        assert result["description"]  # truthy, not empty
+
+    async def test_case_insensitive_match(self):
+        with patch("app.clients.openfda_client._fetch_label_text", new=AsyncMock(
+            return_value="IBUPROFEN increases bleeding risk when combined with warfarin."
+        )):
+            result = await openfda_client.check_pair("warfarin", "ibuprofen")
+        assert result is not None
+
+
+class TestFetchLabelText:
+    async def test_fetches_and_joins_drug_interactions_array(self):
+        """drug_interactions is a JSON array — must be joined into one string."""
+        mock_resp = make_response(WARFARIN_LABEL)
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get.return_value = mock_resp
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            text = await openfda_client._fetch_label_text("warfarin")
+        assert "Ibuprofen" in text
+        assert "monitored" in text  # from second paragraph
+
+    async def test_returns_empty_string_when_no_drug_interactions_field(self):
+        mock_resp = make_response(WARFARIN_LABEL_NO_INTERACTIONS)
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get.return_value = mock_resp
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            text = await openfda_client._fetch_label_text("warfarin")
+        assert text == ""
+
+    async def test_returns_none_on_empty_results(self):
+        mock_resp = make_response(EMPTY_RESULTS)
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get.return_value = mock_resp
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            text = await openfda_client._fetch_label_text("unknowndrug")
+        assert text is None
+
+    async def test_returns_none_on_network_error(self):
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get.side_effect = Exception("network error")
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            text = await openfda_client._fetch_label_text("warfarin")
+        assert text is None
+
+    async def test_caches_label_text(self):
+        mock_resp = make_response(WARFARIN_LABEL)
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get.return_value = mock_resp
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            await openfda_client._fetch_label_text("warfarin")
+            await openfda_client._fetch_label_text("warfarin")
+            assert mock_client.get.call_count == 1  # second call hits cache
+
+    async def test_url_uses_phrase_quoting_for_multiword_name(self):
+        mock_resp = make_response(EMPTY_RESULTS)
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.get.return_value = mock_resp
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            await openfda_client._fetch_label_text("acetylsalicylic acid")
+            call_args = mock_client.get.call_args
+            url = call_args[0][0] if call_args[0] else call_args[1].get("url", "")
+            # Drug name must be quoted for phrase search
+            assert '%22acetylsalicylic' in url or '"acetylsalicylic' in url

tests/test_rxnorm_client.py

@@ -0,0 +1,48 @@
+"""Integration tests for RxNorm client — hits live API."""
+
+import pytest
+
+from app.clients import rxnorm_client
+
+
+@pytest.mark.asyncio
+async def test_get_rxcui_ibuprofen():
+    """Ibuprofen should resolve to RxCUI 5640."""
+    rxcui = await rxnorm_client.get_rxcui("ibuprofen")
+    assert rxcui == "5640"
+
+
+@pytest.mark.asyncio
+async def test_get_rxcui_unknown():
+    """Nonsense drug name should return None."""
+    rxcui = await rxnorm_client.get_rxcui("xyznotadrug123")
+    assert rxcui is None
+
+
+@pytest.mark.asyncio
+async def test_approximate_term_advil():
+    """Brand name 'Advil' should find candidates, resolve to Ibuprofen via details."""
+    results = await rxnorm_client.approximate_term("Advil")
+    assert len(results) > 0
+    # The approximate endpoint returns brand-name concepts (e.g. "Advil").
+    # To get the generic name, we look up details on the first result's RxCUI.
+    assert any("advil" in r.name.lower() for r in results)
+    details = await rxnorm_client.get_drug_details(results[0].rxcui)
+    # RxCUI 153010 maps to the Advil brand of Ibuprofen
+    assert details is not None
+
+
+@pytest.mark.asyncio
+async def test_search_by_name_warfarin():
+    """Warfarin should return drug concepts."""
+    results = await rxnorm_client.search_by_name("warfarin")
+    assert len(results) > 0
+    assert any("warfarin" in r.name.lower() for r in results)
+
+
+@pytest.mark.asyncio
+async def test_get_drug_details():
+    """RxCUI 5640 (Ibuprofen) should return properties."""
+    details = await rxnorm_client.get_drug_details("5640")
+    assert details is not None
+    assert details.get("name", "").lower() == "ibuprofen"

tests/test_severity_classifier.py

@@ -0,0 +1,131 @@
+"""Tests for the zero-shot severity classifier."""
+
+import pytest
+from unittest.mock import patch, MagicMock
+from app.nlp import severity_classifier
+
+
+class TestClassify:
+    """Test classify() with a mocked pipeline so tests run without the model."""
+
+    @pytest.fixture(autouse=True)
+    def mock_pipeline(self):
+        """Mock the classifier pipeline for all tests in this class."""
+        mock = MagicMock()
+        severity_classifier._classifier = mock
+        yield mock
+        severity_classifier._classifier = None
+
+    def test_major_severity(self, mock_pipeline):
+        mock_pipeline.return_value = {
+            "labels": [
+                "critical dangerous interaction",
+                "moderate interaction requiring monitoring",
+                "minor interaction with low risk",
+            ],
+            "scores": [0.85, 0.10, 0.05],
+        }
+        severity, uncertain = severity_classifier.classify("contraindicated combination")
+        assert severity == "major"
+
+    def test_moderate_severity(self, mock_pipeline):
+        mock_pipeline.return_value = {
+            "labels": [
+                "moderate interaction requiring monitoring",
+                "critical dangerous interaction",
+                "minor interaction with low risk",
+            ],
+            "scores": [0.70, 0.20, 0.10],
+        }
+        severity, uncertain = severity_classifier.classify("monitor blood pressure")
+        assert severity == "moderate"
+
+    def test_minor_severity(self, mock_pipeline):
+        mock_pipeline.return_value = {
+            "labels": [
+                "minor interaction with low risk",
+                "moderate interaction requiring monitoring",
+                "critical dangerous interaction",
+            ],
+            "scores": [0.75, 0.15, 0.10],
+        }
+        severity, uncertain = severity_classifier.classify("minimal clinical significance")
+        assert severity == "minor"
+
+    def test_returns_tuple_with_uncertain_flag(self, mock_pipeline):
+        mock_pipeline.return_value = {
+            "labels": [
+                "critical dangerous interaction",
+                "moderate interaction requiring monitoring",
+                "minor interaction with low risk",
+            ],
+            "scores": [0.85, 0.10, 0.05],
+        }
+        severity, uncertain = severity_classifier.classify("contraindicated combination")
+        assert severity == "major"
+        assert uncertain is False
+
+    def test_low_confidence_returns_major_uncertain(self, mock_pipeline):
+        """Below threshold (0.7), classifier should return major+uncertain."""
+        mock_pipeline.return_value = {
+            "labels": [
+                "minor interaction with low risk",
+                "moderate interaction requiring monitoring",
+                "critical dangerous interaction",
+            ],
+            "scores": [0.45, 0.35, 0.20],
+        }
+        severity, uncertain = severity_classifier.classify("some vague description")
+        assert severity == "major"
+        assert uncertain is True
+
+    def test_empty_description(self, mock_pipeline):
+        severity, uncertain = severity_classifier.classify("")
+        assert severity == "unknown"
+        assert uncertain is True
+        mock_pipeline.assert_not_called()
+
+    def test_none_description(self, mock_pipeline):
+        severity, uncertain = severity_classifier.classify(None)
+        assert severity == "unknown"
+        assert uncertain is True
+        mock_pipeline.assert_not_called()
+
+    def test_inference_failure_falls_back_to_regex(self, mock_pipeline):
+        mock_pipeline.side_effect = RuntimeError("OOM")
+        severity, uncertain = severity_classifier.classify("contraindicated")
+        assert severity == "major"
+        assert uncertain is True
+
+
+class TestRegexFallback:
+    """Test the regex fallback when the model is not loaded."""
+
+    @pytest.fixture(autouse=True)
+    def unload_model(self):
+        severity_classifier._classifier = None
+        yield
+        severity_classifier._classifier = None
+
+    def test_fallback_major(self):
+        result = severity_classifier._regex_fallback("Do not use, contraindicated.")
+        assert result == "major"
+
+    def test_fallback_moderate(self):
+        result = severity_classifier._regex_fallback("Use caution, monitor closely.")
+        assert result == "moderate"
+
+    def test_fallback_unknown_for_neutral_text(self):
+        """Unrecognized text now defaults to 'major' for safety."""
+        result = severity_classifier._regex_fallback("No significant interaction.")
+        assert result == "major"
+
+    def test_classify_uses_fallback_when_unloaded(self):
+        severity, uncertain = severity_classifier.classify("contraindicated")
+        assert severity == "major"
+
+
+class TestLoadModel:
+    def test_is_loaded_false_initially(self):
+        severity_classifier._classifier = None
+        assert severity_classifier.is_loaded() is False

tests/test_severity_parser.py

@@ -0,0 +1,87 @@
+"""Tests for the DrugBank template-aware severity parser."""
+
+from app.nlp.severity_parser import parse_severity
+
+
+class TestRiskOrSeverityTemplate:
+    """'The risk or severity of X can be increased/decreased' → major."""
+
+    def test_bleeding_risk(self):
+        desc = "The risk or severity of bleeding can be increased when Aspirin is combined with Warfarin."
+        assert parse_severity(desc) == "major"
+
+    def test_adverse_effects(self):
+        desc = "The risk or severity of adverse effects can be increased when Drug A is combined with Drug B."
+        assert parse_severity(desc) == "major"
+
+    def test_hemorrhage(self):
+        desc = "The risk or severity of bleeding and hemorrhage can be increased when Dasatinib is combined with Warfarin."
+        assert parse_severity(desc) == "major"
+
+    def test_gastrointestinal_bleeding(self):
+        desc = "The risk or severity of gastrointestinal bleeding can be increased when Warfarin is combined with Deferasirox."
+        assert parse_severity(desc) == "major"
+
+
+class TestActivityTemplate:
+    """'may increase/decrease the X activities' → moderate/minor."""
+
+    def test_increase_anticoagulant(self):
+        desc = "Apixaban may increase the anticoagulant activities of Warfarin."
+        assert parse_severity(desc) == "moderate"
+
+    def test_increase_hypotensive(self):
+        desc = "Lisinopril may increase the hypotensive activities of Amlodipine."
+        assert parse_severity(desc) == "moderate"
+
+    def test_decrease_activities(self):
+        desc = "Rifampin may decrease the anticoagulant activities of Warfarin."
+        assert parse_severity(desc) == "minor"
+
+
+class TestConcentrationTemplate:
+    """'serum concentration can be increased/decreased' → moderate."""
+
+    def test_concentration_increased(self):
+        desc = "The serum concentration of Alfuzosin can be increased when it is combined with Lepirudin."
+        assert parse_severity(desc) == "moderate"
+
+    def test_concentration_decreased(self):
+        desc = "The serum concentration of Warfarin can be decreased when it is combined with Rifampin."
+        assert parse_severity(desc) == "moderate"
+
+
+class TestMetabolismTemplate:
+    """'metabolism can be increased/decreased' → moderate."""
+
+    def test_metabolism_increased(self):
+        desc = "The metabolism of Lepirudin can be increased when combined with St. John's Wort."
+        assert parse_severity(desc) == "moderate"
+
+    def test_metabolism_decreased(self):
+        desc = "The metabolism of Warfarin can be decreased when combined with Fluconazole."
+        assert parse_severity(desc) == "moderate"
+
+
+class TestEfficacyTemplate:
+    """'therapeutic efficacy can be decreased' → minor."""
+
+    def test_efficacy_decreased(self):
+        desc = "The therapeutic efficacy of Rotavirus vaccine can be decreased when used in combination with Etanercept."
+        assert parse_severity(desc) == "minor"
+
+
+class TestEdgeCases:
+    def test_empty_string(self):
+        assert parse_severity("") == "unknown"
+
+    def test_none(self):
+        assert parse_severity(None) == "unknown"
+
+    def test_unrecognized_template(self):
+        desc = "Some completely novel interaction description format."
+        assert parse_severity(desc) == "unknown"
+
+    def test_case_insensitive(self):
+        desc = "THE RISK OR SEVERITY OF BLEEDING CAN BE INCREASED WHEN ASPIRIN IS COMBINED WITH WARFARIN."
+        assert parse_severity(desc) == "major"

uv.lock

@@ -113,14 +113,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b5/36/7fb70f04bf00bc646cd5bb45aa9eddb15e19437a28b8fb2b4a5249fac770/filelock-3.20.3-py3-none-any.whl", hash = "sha256:4b0dda527ee31078689fc205ec4f1c1bf7d56cf88b6dc9426c4f230e46c2dce1", size = 16701, upload-time = "2026-01-09T17:55:04.334Z" },
 ]
 
-[[package]]
-name = "flatbuffers"
-version = "25.12.19"
-source = { registry = "https://pypi.org/simple" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e8/2d/d2a548598be01649e2d46231d151a6c56d10b964d94043a335ae56ea2d92/flatbuffers-25.12.19-py2.py3-none-any.whl", hash = "sha256:7634f50c427838bb021c2d66a3d1168e9d199b0607e6329399f04846d42e20b4", size = 26661, upload-time = "2025-12-19T23:16:13.622Z" },
-]
-
 [[package]]
 name = "fsspec"
 version = "2026.2.0"
@@ -130,24 +122,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e6/ab/fb21f4c939bb440104cc2b396d3be1d9b7a9fd3c6c2a53d98c45b3d7c954/fsspec-2026.2.0-py3-none-any.whl", hash = "sha256:98de475b5cb3bd66bedd5c4679e87b4fdfe1a3bf4d707b151b3c07e58c9a2437", size = 202505, upload-time = "2026-02-05T21:50:51.819Z" },
 ]
 
-[[package]]
-name = "gliner"
-version = "0.2.26"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "huggingface-hub" },
-    { name = "onnxruntime" },
-    { name = "sentencepiece" },
-    { name = "torch", version = "2.11.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform == 'darwin'" },
-    { name = "torch", version = "2.11.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform != 'darwin'" },
-    { name = "tqdm" },
-    { name = "transformers" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/49/18/e199cb97147c4a9260c75e4caf51e17be6ff969b0604a029c9c62810cbe0/gliner-0.2.26.tar.gz", hash = "sha256:6783be92b4b81caa878dcc4269ba37800207c37118d8ff9be028b93bddd6813d", size = 181224, upload-time = "2026-03-19T15:07:22.707Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7c/6e/d54d3d2867e29b68a22b144f570c8204209647fccc7879cec5218d6ed5fb/gliner-0.2.26-py3-none-any.whl", hash = "sha256:b9baa47641efb90b9d069add0528ed2464d137991ff097f42b0cab37a91ba991", size = 170429, upload-time = "2026-03-19T15:07:19.914Z" },
-]
-
 [[package]]
 name = "h11"
 version = "0.16.0"
@@ -336,24 +310,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2f/a3/56c5c604fae6dd40fa2ed3040d005fca97e91bd320d232ac9931d77ba13c/numpy-2.4.2-cp312-cp312-win_arm64.whl", hash = "sha256:fbde1b0c6e81d56f5dccd95dd4a711d9b95df1ae4009a60887e56b27e8d903fa", size = 10220171, upload-time = "2026-01-31T23:11:14.684Z" },
 ]
 
-[[package]]
-name = "onnxruntime"
-version = "1.25.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "flatbuffers" },
-    { name = "numpy" },
-    { name = "packaging" },
-    { name = "protobuf" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7a/69/f98c6bda4c34ac382b70c36033a989ceffd1caf5afba47bd2ef26535850f/onnxruntime-1.25.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:8ecd3362de3fb496fb3e2d055a95d5acab611cf759a27609c6d99704c9d8f184", size = 17742518, upload-time = "2026-04-22T17:20:34.444Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/c6/19c5bfbc60396791e975652f982bcff9ff4b27947c8e2bf0064ac5d5727b/onnxruntime-1.25.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c99238d20bfa80ac68c7b03c2c936d389189ae40997f78a30d151570d7e18bf", size = 15841110, upload-time = "2026-04-22T17:19:31.284Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/1b/d681878f227513917d8620e4ea504af5eb3313fc01f8aea7b19a976c65db/onnxruntime-1.25.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be93baa694ef8e5831fcb7b542da21f502b122918b5b9612d9f02972e043ee01", size = 17996146, upload-time = "2026-04-22T17:19:53.792Z" },
-    { url = "https://files.pythonhosted.org/packages/55/fe/ec98e416bd75063dea1e493661c7c939e18660ee41d6a63d7221e5657f48/onnxruntime-1.25.0-cp312-cp312-win_amd64.whl", hash = "sha256:9596040c1f7d247bbfab5d4db1e7651c790235e48e460c7d445ec81687d5a182", size = 12872370, upload-time = "2026-04-22T17:20:22.856Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/86/9a1ac7c8a8eba7967935d4c109fc956d8f9ba61cba61d9368315bb27d0bc/onnxruntime-1.25.0-cp312-cp312-win_arm64.whl", hash = "sha256:463aed7f5e4a3ca5a476db7e9bba9164fa26921ef34c37e59b28c4c61e55f266", size = 12600072, upload-time = "2026-04-22T17:20:11.523Z" },
-]
-
 [[package]]
 name = "packaging"
 version = "26.0"
@@ -379,11 +335,6 @@ dependencies = [
     { name = "uvicorn", extra = ["standard"] },
 ]
 
-[package.optional-dependencies]
-gliner = [
-    { name = "gliner" },
-]
-
 [package.dev-dependencies]
 dev = [
     { name = "pytest" },
@@ -394,7 +345,6 @@ dev = [
 requires-dist = [
     { name = "aiosqlite", specifier = ">=0.22.1" },
     { name = "fastapi", specifier = ">=0.115.0" },
-    { name = "gliner", marker = "extra == 'gliner'" },
     { name = "httpx", specifier = ">=0.28.0" },
     { name = "pydantic", specifier = ">=2.10.0" },
     { name = "slowapi", specifier = ">=0.1.9" },
@@ -402,7 +352,6 @@ requires-dist = [
     { name = "transformers", specifier = ">=4.48.0" },
     { name = "uvicorn", extras = ["standard"], specifier = ">=0.34.0" },
 ]
-provides-extras = ["gliner"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -419,21 +368,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
 ]
 
-[[package]]
-name = "protobuf"
-version = "7.34.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6b/6b/a0e95cad1ad7cc3f2c6821fcab91671bd5b78bd42afb357bb4765f29bc41/protobuf-7.34.1.tar.gz", hash = "sha256:9ce42245e704cc5027be797c1db1eb93184d44d1cdd71811fb2d9b25ad541280", size = 454708, upload-time = "2026-03-20T17:34:47.036Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ec/11/3325d41e6ee15bf1125654301211247b042563bcc898784351252549a8ad/protobuf-7.34.1-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:d8b2cc79c4d8f62b293ad9b11ec3aebce9af481fa73e64556969f7345ebf9fc7", size = 429247, upload-time = "2026-03-20T17:34:37.024Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/9d/aa69df2724ff63efa6f72307b483ce0827f4347cc6d6df24b59e26659fef/protobuf-7.34.1-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:5185e0e948d07abe94bb76ec9b8416b604cfe5da6f871d67aad30cbf24c3110b", size = 325753, upload-time = "2026-03-20T17:34:38.751Z" },
-    { url = "https://files.pythonhosted.org/packages/92/e8/d174c91fd48e50101943f042b09af9029064810b734e4160bbe282fa1caa/protobuf-7.34.1-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:403b093a6e28a960372b44e5eb081775c9b056e816a8029c61231743d63f881a", size = 340198, upload-time = "2026-03-20T17:34:39.871Z" },
-    { url = "https://files.pythonhosted.org/packages/53/1b/3b431694a4dc6d37b9f653f0c64b0a0d9ec074ee810710c0c3da21d67ba7/protobuf-7.34.1-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:8ff40ce8cd688f7265326b38d5a1bed9bfdf5e6723d49961432f83e21d5713e4", size = 324267, upload-time = "2026-03-20T17:34:41.1Z" },
-    { url = "https://files.pythonhosted.org/packages/85/29/64de04a0ac142fb685fd09999bc3d337943fb386f3a0ec57f92fd8203f97/protobuf-7.34.1-cp310-abi3-win32.whl", hash = "sha256:34b84ce27680df7cca9f231043ada0daa55d0c44a2ddfaa58ec1d0d89d8bf60a", size = 426628, upload-time = "2026-03-20T17:34:42.536Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/87/cb5e585192a22b8bd457df5a2c16a75ea0db9674c3a0a39fc9347d84e075/protobuf-7.34.1-cp310-abi3-win_amd64.whl", hash = "sha256:e97b55646e6ce5cbb0954a8c28cd39a5869b59090dfaa7df4598a7fba869468c", size = 437901, upload-time = "2026-03-20T17:34:44.112Z" },
-    { url = "https://files.pythonhosted.org/packages/88/95/608f665226bca68b736b79e457fded9a2a38c4f4379a4a7614303d9db3bc/protobuf-7.34.1-py3-none-any.whl", hash = "sha256:bb3812cd53aefea2b028ef42bd780f5b96407247f20c6ef7c679807e9d188f11", size = 170715, upload-time = "2026-03-20T17:34:45.384Z" },
-]
-
 [[package]]
 name = "pydantic"
 version = "2.12.5"
@@ -518,11 +452,11 @@ wheels = [
 
 [[package]]
 name = "python-dotenv"
-version = "1.2.1"
+version = "1.2.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f0/26/19cadc79a718c5edbec86fd4919a6b6d3f681039a2f6d66d14be94e75fb9/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6", size = 44221, upload-time = "2025-10-26T15:12:10.434Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/1b/a298b06749107c305e1fe0f814c6c74aea7b2f1e10989cb30f544a1b3253/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61", size = 21230, upload-time = "2025-10-26T15:12:09.109Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
 ]
 
 [[package]]
@@ -589,22 +523,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5d/e6/ec8471c8072382cb91233ba7267fd931219753bb43814cbc71757bfd4dab/safetensors-0.7.0-cp38-abi3-win_amd64.whl", hash = "sha256:d1239932053f56f3456f32eb9625590cc7582e905021f94636202a864d470755", size = 341380, upload-time = "2025-11-19T15:18:44.427Z" },
 ]
 
-[[package]]
-name = "sentencepiece"
-version = "0.2.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/15/15/2e7a025fc62d764b151ae6d0f2a92f8081755ebe8d4a64099accc6f77ba6/sentencepiece-0.2.1.tar.gz", hash = "sha256:8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad", size = 3228515, upload-time = "2025-08-12T07:00:51.718Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4a/be/32ce495aa1d0e0c323dcb1ba87096037358edee539cac5baf8755a6bd396/sentencepiece-0.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:57cae326c8727de58c85977b175af132a7138d84c764635d7e71bbee7e774133", size = 1943152, upload-time = "2025-08-12T06:59:40.048Z" },
-    { url = "https://files.pythonhosted.org/packages/88/7e/ff23008899a58678e98c6ff592bf4d368eee5a71af96d0df6b38a039dd4f/sentencepiece-0.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:56dd39a3c4d6493db3cdca7e8cc68c6b633f0d4195495cbadfcf5af8a22d05a6", size = 1325651, upload-time = "2025-08-12T06:59:41.536Z" },
-    { url = "https://files.pythonhosted.org/packages/19/84/42eb3ce4796777a1b5d3699dfd4dca85113e68b637f194a6c8d786f16a04/sentencepiece-0.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d9381351182ff9888cc80e41c632e7e274b106f450de33d67a9e8f6043da6f76", size = 1253645, upload-time = "2025-08-12T06:59:42.903Z" },
-    { url = "https://files.pythonhosted.org/packages/89/fa/d3d5ebcba3cb9e6d3775a096251860c41a6bc53a1b9461151df83fe93255/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99f955df238021bf11f0fc37cdb54fd5e5b5f7fd30ecc3d93fb48b6815437167", size = 1316273, upload-time = "2025-08-12T06:59:44.476Z" },
-    { url = "https://files.pythonhosted.org/packages/04/88/14f2f4a2b922d8b39be45bf63d79e6cd3a9b2f248b2fcb98a69b12af12f5/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b", size = 1387881, upload-time = "2025-08-12T06:59:46.09Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/b8/903e5ccb77b4ef140605d5d71b4f9e0ad95d456d6184688073ed11712809/sentencepiece-0.2.1-cp312-cp312-win32.whl", hash = "sha256:a483fd29a34c3e34c39ac5556b0a90942bec253d260235729e50976f5dba1068", size = 999540, upload-time = "2025-08-12T06:59:48.023Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/81/92df5673c067148c2545b1bfe49adfd775bcc3a169a047f5a0e6575ddaca/sentencepiece-0.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:4cdc7c36234fda305e85c32949c5211faaf8dd886096c7cea289ddc12a2d02de", size = 1054671, upload-time = "2025-08-12T06:59:49.895Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/02/c5e3bc518655d714622bec87d83db9cdba1cd0619a4a04e2109751c4f47f/sentencepiece-0.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:daeb5e9e9fcad012324807856113708614d534f596d5008638eb9b40112cd9e4", size = 1033923, upload-time = "2025-08-12T06:59:51.952Z" },
-]
-
 [[package]]
 name = "setuptools"
 version = "81.0.0"
@@ -703,7 +621,7 @@ dependencies = [
     { name = "typing-extensions", marker = "sys_platform == 'darwin'" },
 ]
 wheels = [
-    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:43b35116802c85fb88d99f4a396b8bd4472bfca1dd82e69499e5a4f9b8b4e252", upload-time = "2026-03-23T15:16:58Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:43b35116802c85fb88d99f4a396b8bd4472bfca1dd82e69499e5a4f9b8b4e252" },
 ]
 
 [[package]]
@@ -723,10 +641,10 @@ dependencies = [
     { name = "typing-extensions", marker = "sys_platform != 'darwin'" },
 ]
 wheels = [
-    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.11.0%2Bcpu-cp312-cp312-linux_s390x.whl", upload-time = "2026-03-23T14:59:01Z" },
-    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.11.0%2Bcpu-cp312-cp312-manylinux_2_28_aarch64.whl", upload-time = "2026-03-23T14:59:02Z" },
-    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.11.0%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl", upload-time = "2026-03-23T14:59:03Z" },
-    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.11.0%2Bcpu-cp312-cp312-win_amd64.whl", upload-time = "2026-03-23T14:59:04Z" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.11.0%2Bcpu-cp312-cp312-linux_s390x.whl" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.11.0%2Bcpu-cp312-cp312-manylinux_2_28_aarch64.whl" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.11.0%2Bcpu-cp312-cp312-manylinux_2_28_x86_64.whl" },
+    { url = "https://download-r2.pytorch.org/whl/cpu/torch-2.11.0%2Bcpu-cp312-cp312-win_amd64.whl" },
 ]
 
 [[package]]