┌─────────────────────────────────────────────────────────────────────────────┐
│                    ON-DEVICE MEDICAL SCRIBE ARCHITECTURE                     │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌───────────────────────────────────────────────────────────────────────┐  │
│  │ LOCAL DEVICE (All Processing On-Device)                               │  │
│  │                                                                       │  │
│  │   ┌─────────────┐                                                     │  │
│  │   │ Audio Input │  Microphone / WAV / MP3 upload                     │  │
│  │   └──────┬──────┘                                                     │  │
│  │          │                                                            │  │
│  │          ▼                                                            │  │
│  │   ┌─────────────────────────────────────────────────┐                 │  │
│  │   │ whisper.cpp (Local ASR)                          │                 │  │
│  │   │ • Speech-to-text transcription                   │                 │  │
│  │   │ • Speaker turn detection via pause duration      │                 │  │
│  │   └──────┬──────────────────────────────────────────┘                 │  │
│  │          │                                                            │  │
│  │          ▼                                                            │  │
│  │   ┌─────────────────────────────────────────────────┐                 │  │
│  │   │ Medical Entity Extraction                        │                 │  │
│  │   │ • Regex: vitals (BP, HR, temp, SpO2)            │                 │  │
│  │   │ • SLM: symptoms, diagnoses, medications         │                 │  │
│  │   └──────┬──────────────────────────────────────────┘                 │  │
│  │          │                                                            │  │
│  │          ▼                                                            │  │
│  │   ┌─────────────────────────────────────────────────┐                 │  │
│  │   │ SOAP Note Generator (SLM)                        │                 │  │
│  │   │ • Section-specific prompts: S / O / A / P        │                 │  │
│  │   │ • Template-constrained generation                │                 │  │
│  │   └──────┬──────────────────────────────────────────┘                 │  │
│  │          │                                                            │  │
│  │    ┌─────┴──────┐                                                     │  │
│  │    │            │                                                     │  │
│  │    ▼            ▼                                                     │  │
│  │ ┌──────────┐ ┌──────────────┐                                         │  │
│  │ │ ICD-10   │ │ FHIR Export  │                                         │  │
│  │ │ Lookup   │ │ (R4 JSON)    │                                         │  │
│  │ │ (SQLite) │ │              │                                         │  │
│  │ └──────────┘ └──────────────┘                                         │  │
│  │                                                                       │  │
│  └───────────────────────────────────────────────────────────────────────┘  │
│                                                                             │
│  NO CLOUD SERVICES ──── NO API CALLS ──── NO DATA LEAVES DEVICE            │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

medical-scribe/
├── src/
│   ├── __init__.py
│   ├── config.py
│   ├── transcription/
│   │   ├── __init__.py
│   │   ├── whisper_engine.py    # Local speech-to-text
│   │   └── speaker_detect.py   # Speaker turn detection
│   ├── extraction/
│   │   ├── __init__.py
│   │   ├── vitals_regex.py     # Regex-based vital sign extraction
│   │   ├── medical_ner.py      # SLM-based entity extraction
│   │   └── models.py           # Entity data models
│   ├── documentation/
│   │   ├── __init__.py
│   │   ├── soap_generator.py   # SOAP note generation
│   │   └── templates.py        # Section-specific prompt templates
│   ├── coding/
│   │   ├── __init__.py
│   │   └── icd10_lookup.py     # Local ICD-10 code database
│   ├── export/
│   │   ├── __init__.py
│   │   ├── fhir_exporter.py    # FHIR R4 document generation
│   │   └── storage.py          # SQLite encounter storage
│   ├── models/
│   │   ├── __init__.py
│   │   └── slm_engine.py       # Local SLM inference engine
│   └── app/
│       ├── __init__.py
│       └── interface.py         # Gradio interface
├── models/                       # Downloaded GGUF models
├── data/
│   └── icd10_codes.db           # Local ICD-10 database
├── tests/
└── requirements.txt

# src/config.py
from pydantic_settings import BaseSettings
from pathlib import Path
from typing import List

class Settings(BaseSettings):
    # Whisper Settings (local)
    whisper_model_path: Path = Path("./models/ggml-base.en.bin")
    whisper_language: str = "en"
    whisper_threads: int = 4

    # SLM Settings (local)
    slm_model_path: Path = Path("./models/phi-3-mini-4k-instruct.Q4_K_M.gguf")
    slm_context_length: int = 4096
    slm_max_tokens: int = 512
    slm_temperature: float = 0.3
    slm_threads: int = 4

    # Embedding Settings (local)
    embedding_model: str = "all-MiniLM-L6-v2"

    # ICD-10 Database
    icd10_db_path: Path = Path("./data/icd10_codes.db")

    # Encounter Storage
    encounter_db_path: Path = Path("./data/encounters.db")

    # Speaker Detection
    pause_threshold_seconds: float = 1.5
    min_segment_words: int = 3

    # SOAP Note Settings
    max_subjective_length: int = 300
    max_objective_length: int = 200
    max_assessment_length: int = 250
    max_plan_length: int = 300

    # Privacy (all local, no cloud)
    enable_audio_retention: bool = False  # Don't store raw audio
    encounter_retention_days: int = 90

    class Config:
        env_file = ".env"

settings = Settings()

┌─────────────────────────────────────────────────────────────────────┐
│ HIPAA COMPLIANCE BY ARCHITECTURE                                      │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Traditional Cloud-Based Scribe:                                    │
│  Audio ──► Cloud ASR ──► Cloud NLP ──► Cloud Storage                │
│       ↑        ↑            ↑              ↑                        │
│       └────────┴────────────┴──────────────┘                        │
│       PHI travels through multiple third-party services             │
│       Each service = BAA required + security audit                  │
│                                                                     │
│  This On-Device Approach:                                           │
│  Audio ──► Local Whisper ──► Local SLM ──► Local SQLite             │
│       ↑                                                             │
│       └── PHI never leaves the device                               │
│           No BAAs needed for AI services                            │
│           No cloud breach risk                                      │
│                                                                     │
│  NO API KEYS IN THIS CONFIG                                         │
│  └── Notice: zero API key settings                                  │
│      Everything runs from local model files and SQLite              │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/transcription/whisper_engine.py
from typing import List, Optional
from dataclasses import dataclass, field
from pathlib import Path
from pywhispercpp.model import Model as WhisperModel
from ..config import settings

@dataclass
class TranscriptSegment:
    """A single segment of transcribed audio."""
    text: str
    start_time: float  # seconds
    end_time: float    # seconds
    speaker: str = "unknown"  # "doctor" or "patient"

@dataclass
class Transcript:
    """Complete transcript with speaker attribution."""
    segments: List[TranscriptSegment] = field(default_factory=list)
    full_text: str = ""
    duration_seconds: float = 0.0

    @property
    def doctor_text(self) -> str:
        return " ".join(
            s.text for s in self.segments if s.speaker == "doctor"
        )

    @property
    def patient_text(self) -> str:
        return " ".join(
            s.text for s in self.segments if s.speaker == "patient"
        )


class WhisperEngine:
    """Local speech-to-text using whisper.cpp.

    Uses pywhispercpp (Python bindings for whisper.cpp) for
    CPU-efficient transcription without cloud services.
    """

    def __init__(self, model_path: str = None):
        self.model_path = model_path or str(settings.whisper_model_path)
        self.model = WhisperModel(
            self.model_path,
            n_threads=settings.whisper_threads
        )

    def transcribe(self, audio_path: str) -> Transcript:
        """Transcribe an audio file to text with timestamps."""
        segments = self.model.transcribe(audio_path)

        transcript_segments = []
        for segment in segments:
            transcript_segments.append(TranscriptSegment(
                text=segment.text.strip(),
                start_time=segment.t0 / 100.0,  # Convert to seconds
                end_time=segment.t1 / 100.0
            ))

        # Detect speaker turns based on pauses
        transcript_segments = self._detect_speakers(transcript_segments)

        full_text = " ".join(s.text for s in transcript_segments)

        duration = (
            transcript_segments[-1].end_time
            if transcript_segments else 0.0
        )

        return Transcript(
            segments=transcript_segments,
            full_text=full_text,
            duration_seconds=duration
        )

    def _detect_speakers(
        self,
        segments: List[TranscriptSegment]
    ) -> List[TranscriptSegment]:
        """Simple speaker diarization based on pause duration.

        Assumption: In a clinical encounter, speakers alternate.
        Long pauses (>1.5s) indicate speaker change.
        First speaker is assumed to be the doctor.
        """
        if not segments:
            return segments

        current_speaker = "doctor"
        segments[0].speaker = current_speaker

        for i in range(1, len(segments)):
            gap = segments[i].start_time - segments[i - 1].end_time

            if gap >= settings.pause_threshold_seconds:
                # Speaker change
                current_speaker = (
                    "patient" if current_speaker == "doctor"
                    else "doctor"
                )

            segments[i].speaker = current_speaker

        return segments

    def transcribe_stream(self, audio_chunks: list) -> Transcript:
        """Transcribe streaming audio chunks.

        For real-time transcription, process audio in chunks
        and accumulate segments.
        """
        all_segments = []

        for chunk_path in audio_chunks:
            segments = self.model.transcribe(chunk_path)
            for segment in segments:
                all_segments.append(TranscriptSegment(
                    text=segment.text.strip(),
                    start_time=segment.t0 / 100.0,
                    end_time=segment.t1 / 100.0
                ))

        all_segments = self._detect_speakers(all_segments)

        return Transcript(
            segments=all_segments,
            full_text=" ".join(s.text for s in all_segments),
            duration_seconds=(
                all_segments[-1].end_time if all_segments else 0.0
            )
        )

┌─────────────────────────────────────────────────────────────────────┐
│ WHISPER MODEL SELECTION FOR MEDICAL USE                               │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Model       Size      Speed     Accuracy   Best For                │
│  ─────────   ───────   ───────   ────────   ──────────────────      │
│  tiny        39 MB     Fastest   ~78%       Quick notes             │
│  base        74 MB     Fast      ~84%       Standard encounters ◄   │
│  small       244 MB    Medium    ~90%       Complex terminology     │
│  medium      769 MB    Slow      ~93%       Heavy accents           │
│  large       1.5 GB    Slowest   ~96%       Maximum accuracy        │
│                                                                     │
│  "base.en" is recommended for:                                      │
│  • English-only clinical encounters                                 │
│  • Good balance of speed and accuracy for medical terminology       │
│  • Fast enough for near-real-time on modern CPU                     │
│  • Small enough for edge deployment                                 │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────┐
│ PAUSE-BASED SPEAKER DIARIZATION                                       │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Time: 0s────5s────10s────15s────20s────25s────30s                  │
│                                                                     │
│  Doctor:  ████████              ████████████                         │
│  Gap:              ▓▓▓▓▓▓▓▓▓                                       │
│  Patient:          (1.8s gap)   ██████████████                      │
│                    ↑                                                │
│                    gap > 1.5s → speaker change                      │
│                                                                     │
│  WHY PAUSE-BASED (not ML diarization):                              │
│  • Zero additional model to load                                    │
│  • Works well for 2-speaker clinical encounters                     │
│  • No training data needed                                          │
│  • Clinical conversations have natural turn-taking pauses           │
│                                                                     │
│  LIMITATIONS:                                                       │
│  • Doesn't work well when speakers overlap                          │
│  • Assumes alternating turns (doctor/patient)                       │
│  • For multi-speaker (nurse, family), need ML diarization           │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/extraction/models.py
from pydantic import BaseModel, Field
from typing import List, Optional, Dict

class VitalSign(BaseModel):
    """A single vital sign measurement."""
    name: str  # BP, HR, temp, SpO2, RR, weight
    value: str
    unit: str
    is_abnormal: bool = False

class MedicalEntity(BaseModel):
    """An extracted medical entity."""
    text: str
    entity_type: str  # symptom, diagnosis, medication, procedure, allergy
    context: Optional[str] = None  # surrounding text

class ExtractedEntities(BaseModel):
    """All entities extracted from a transcript."""
    vitals: List[VitalSign] = Field(default_factory=list)
    symptoms: List[MedicalEntity] = Field(default_factory=list)
    diagnoses: List[MedicalEntity] = Field(default_factory=list)
    medications: List[MedicalEntity] = Field(default_factory=list)
    procedures: List[MedicalEntity] = Field(default_factory=list)
    allergies: List[MedicalEntity] = Field(default_factory=list)
    history: List[MedicalEntity] = Field(default_factory=list)

# src/extraction/vitals_regex.py
import re
from typing import List
from .models import VitalSign

class VitalsExtractor:
    """Extract vital signs from text using regex patterns.

    Regex-based extraction for vitals because:
    1. Vitals follow strict numeric patterns
    2. Regex is deterministic (no hallucination risk)
    3. Zero latency (no model inference)
    4. Vitals are safety-critical data points
    """

    PATTERNS = {
        "blood_pressure": {
            "pattern": r'(?:BP|blood pressure)[:\s]*(\d{2,3})\s*/\s*(\d{2,3})',
            "unit": "mmHg",
            "format": lambda m: f"{m.group(1)}/{m.group(2)}",
            "abnormal": lambda m: int(m.group(1)) > 140 or int(m.group(2)) > 90
                                  or int(m.group(1)) < 90
        },
        "heart_rate": {
            "pattern": r'(?:HR|heart rate|pulse)[:\s]*(\d{2,3})\s*(?:bpm|beats)?',
            "unit": "bpm",
            "format": lambda m: m.group(1),
            "abnormal": lambda m: int(m.group(1)) > 100 or int(m.group(1)) < 60
        },
        "temperature": {
            "pattern": r'(?:temp|temperature)[:\s]*([\d.]+)\s*(?:°?[FC]|degrees)?',
            "unit": "°F",
            "format": lambda m: m.group(1),
            "abnormal": lambda m: float(m.group(1)) > 100.4
                                  or float(m.group(1)) < 96.0
        },
        "oxygen_saturation": {
            "pattern": r'(?:SpO2|O2 sat|oxygen|sat)[:\s]*(\d{2,3})\s*%?',
            "unit": "%",
            "format": lambda m: m.group(1),
            "abnormal": lambda m: int(m.group(1)) < 94
        },
        "respiratory_rate": {
            "pattern": r'(?:RR|respiratory rate|resp rate)[:\s]*(\d{1,2})',
            "unit": "breaths/min",
            "format": lambda m: m.group(1),
            "abnormal": lambda m: int(m.group(1)) > 20 or int(m.group(1)) < 12
        },
        "weight": {
            "pattern": r'(?:weight|wt)[:\s]*([\d.]+)\s*(?:kg|lbs?|pounds?)',
            "unit": "kg",
            "format": lambda m: m.group(1),
            "abnormal": lambda m: False  # Context-dependent
        }
    }

    def extract(self, text: str) -> List[VitalSign]:
        """Extract vital signs from text."""
        vitals = []
        text_lower = text.lower()

        for vital_name, config in self.PATTERNS.items():
            match = re.search(config["pattern"], text_lower)
            if match:
                try:
                    vitals.append(VitalSign(
                        name=vital_name.replace("_", " ").title(),
                        value=config["format"](match),
                        unit=config["unit"],
                        is_abnormal=config["abnormal"](match)
                    ))
                except (ValueError, IndexError):
                    continue

        return vitals

# src/extraction/medical_ner.py
from typing import List
from llama_cpp import Llama
from .models import MedicalEntity, ExtractedEntities, VitalSign
from .vitals_regex import VitalsExtractor
from ..config import settings
import json

class MedicalEntityExtractor:
    """Hybrid entity extraction: regex for vitals, SLM for clinical entities.

    Uses a two-stage approach:
    1. Regex for structured data (vitals) - deterministic, fast
    2. SLM for unstructured data (symptoms, diagnoses) - flexible, contextual
    """

    def __init__(self):
        self.vitals_extractor = VitalsExtractor()
        self.llm = Llama(
            model_path=str(settings.slm_model_path),
            n_ctx=settings.slm_context_length,
            n_threads=settings.slm_threads,
            n_gpu_layers=0,
            verbose=False
        )

    def extract(self, transcript_text: str) -> ExtractedEntities:
        """Extract all medical entities from transcript text."""
        # Stage 1: Regex for vitals (fast, deterministic)
        vitals = self.vitals_extractor.extract(transcript_text)

        # Stage 2: SLM for clinical entities (contextual)
        clinical_entities = self._extract_clinical_entities(transcript_text)

        return ExtractedEntities(
            vitals=vitals,
            symptoms=clinical_entities.get("symptoms", []),
            diagnoses=clinical_entities.get("diagnoses", []),
            medications=clinical_entities.get("medications", []),
            procedures=clinical_entities.get("procedures", []),
            allergies=clinical_entities.get("allergies", []),
            history=clinical_entities.get("history", [])
        )

    def _extract_clinical_entities(
        self,
        text: str
    ) -> dict:
        """Extract clinical entities using local SLM."""
        prompt = f"""<|system|>
You are a medical entity extractor. Extract clinical entities from the
doctor-patient conversation transcript below.

Return JSON with these categories:
- symptoms: patient-reported complaints (e.g., "chest pain", "headache")
- diagnoses: mentioned conditions (e.g., "hypertension", "diabetes")
- medications: drug names (e.g., "metformin", "lisinopril")
- procedures: tests or procedures (e.g., "ECG", "blood work")
- allergies: mentioned allergies (e.g., "penicillin allergy")
- history: relevant medical history (e.g., "prior MI", "family history of CAD")

Only extract entities explicitly mentioned. Do not infer or add entities.
<|end|>
<|user|>
Transcript:
{text[:2000]}

Extract medical entities as JSON.
<|end|>
<|assistant|>
"""

        response = self.llm(
            prompt,
            max_tokens=settings.slm_max_tokens,
            temperature=0.1,
            stop=["<|end|>", "</s>"]
        )

        result_text = response["choices"][0]["text"].strip()

        # Parse JSON response
        try:
            parsed = json.loads(result_text)
            entities = {}
            for category in [
                "symptoms", "diagnoses", "medications",
                "procedures", "allergies", "history"
            ]:
                entities[category] = [
                    MedicalEntity(
                        text=item,
                        entity_type=category.rstrip("s")
                    )
                    for item in parsed.get(category, [])
                    if isinstance(item, str)
                ]
            return entities
        except json.JSONDecodeError:
            return {}

┌─────────────────────────────────────────────────────────────────────┐
│ TWO-STAGE ENTITY EXTRACTION                                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  "BP is 140 over 90, heart rate 88. Patient reports chest pain      │
│   radiating to left arm for 2 hours. Taking metformin and           │
│   lisinopril. Allergic to penicillin."                              │
│         │                                                          │
│         ├──► Stage 1: REGEX (vitals)                               │
│         │    ┌──────────────────────────────────────────┐          │
│         │    │ BP: 140/90 mmHg (ABNORMAL)               │          │
│         │    │ HR: 88 bpm (normal)                      │          │
│         │    └──────────────────────────────────────────┘          │
│         │    Fast, deterministic, never hallucinates                │
│         │                                                          │
│         └──► Stage 2: SLM (clinical entities)                      │
│              ┌──────────────────────────────────────────┐          │
│              │ Symptoms: ["chest pain radiating to      │          │
│              │            left arm for 2 hours"]        │          │
│              │ Medications: ["metformin", "lisinopril"] │          │
│              │ Allergies: ["penicillin"]                │          │
│              └──────────────────────────────────────────┘          │
│              Contextual, handles varied language                    │
│                                                                     │
│  WHY HYBRID:                                                        │
│  • Vitals are safety-critical → regex (no hallucination)           │
│  • Symptoms vary in language → SLM (flexible extraction)           │
│  • Regex runs in <1ms, SLM takes ~2 seconds                    │
│  • Critical data (vitals) available immediately                    │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/documentation/templates.py
"""SOAP note section-specific prompt templates."""

SOAP_SYSTEM_PROMPT = """You are a medical documentation assistant generating
clinical notes for physician review. Write in standard medical documentation
style: concise, objective, using standard abbreviations.

IMPORTANT: Generate a DRAFT for physician review. Do not make clinical
judgments. Document what was discussed and observed."""

SUBJECTIVE_TEMPLATE = """Based on the patient-reported information from this
encounter transcript, write the Subjective section of a SOAP note.

Include:
- Chief complaint (CC)
- History of present illness (HPI): onset, location, duration,
  character, aggravating/relieving factors, timing, severity
- Review of systems (ROS) if discussed
- Relevant past medical/surgical/family/social history if mentioned

Transcript (patient portions):
{patient_text}

Write the Subjective section in standard medical documentation format.
Be concise. Use standard abbreviations (CC, HPI, ROS, PMH)."""

OBJECTIVE_TEMPLATE = """Based on the physician's observations and examination
findings from this encounter, write the Objective section of a SOAP note.

Include:
- Vital signs: {vitals}
- Physical examination findings mentioned
- Any test results discussed
- General appearance observations

Transcript (physician portions):
{doctor_text}

Write the Objective section. Document only what was explicitly stated or
measured. Do not infer findings."""

ASSESSMENT_TEMPLATE = """Based on the clinical entities and encounter context,
write the Assessment section of a SOAP note.

Include:
- Primary assessment/working diagnosis
- Differential considerations if discussed
- Relevant clinical reasoning mentioned

Extracted entities:
- Symptoms: {symptoms}
- Diagnoses discussed: {diagnoses}
- Relevant history: {history}

Transcript summary:
{summary}

Write the Assessment as a numbered problem list. Use standard medical
terminology. Frame as physician's documented assessment."""

PLAN_TEMPLATE = """Based on the encounter discussion, write the Plan section
of a SOAP note.

Include:
- Diagnostic workup ordered (labs, imaging)
- Medications prescribed or adjusted
- Referrals made
- Follow-up instructions
- Patient education provided

Mentioned medications: {medications}
Mentioned procedures: {procedures}

Transcript (physician discussion of plan):
{doctor_text}

Write the Plan section. Only include plans explicitly discussed.
Do not suggest additional plans."""

# src/documentation/soap_generator.py
from typing import Optional
from dataclasses import dataclass
from llama_cpp import Llama
from ..extraction.models import ExtractedEntities
from ..transcription.whisper_engine import Transcript
from .templates import (
    SOAP_SYSTEM_PROMPT,
    SUBJECTIVE_TEMPLATE,
    OBJECTIVE_TEMPLATE,
    ASSESSMENT_TEMPLATE,
    PLAN_TEMPLATE
)
from ..config import settings

@dataclass
class SOAPNote:
    """A complete SOAP note."""
    subjective: str
    objective: str
    assessment: str
    plan: str
    encounter_id: Optional[str] = None

    @property
    def full_note(self) -> str:
        return (
            f"SUBJECTIVE:\n{self.subjective}\n\n"
            f"OBJECTIVE:\n{self.objective}\n\n"
            f"ASSESSMENT:\n{self.assessment}\n\n"
            f"PLAN:\n{self.plan}"
        )


class SOAPGenerator:
    """Generates SOAP notes from transcripts using local SLM.

    Each SOAP section is generated separately with a section-specific
    prompt template. This approach:
    1. Keeps each generation within SLM context limits
    2. Allows section-specific instructions
    3. Makes individual sections independently editable
    """

    def __init__(self):
        self.llm = Llama(
            model_path=str(settings.slm_model_path),
            n_ctx=settings.slm_context_length,
            n_threads=settings.slm_threads,
            n_gpu_layers=0,
            verbose=False
        )

    def generate(
        self,
        transcript: Transcript,
        entities: ExtractedEntities,
        encounter_id: str = None
    ) -> SOAPNote:
        """Generate a complete SOAP note."""
        subjective = self._generate_section(
            SUBJECTIVE_TEMPLATE.format(
                patient_text=transcript.patient_text[:1500]
            ),
            max_tokens=settings.max_subjective_length
        )

        vitals_text = ", ".join([
            f"{v.name}: {v.value} {v.unit}"
            + (" (ABNORMAL)" if v.is_abnormal else "")
            for v in entities.vitals
        ]) or "Not recorded"

        objective = self._generate_section(
            OBJECTIVE_TEMPLATE.format(
                vitals=vitals_text,
                doctor_text=transcript.doctor_text[:1500]
            ),
            max_tokens=settings.max_objective_length
        )

        symptoms_text = ", ".join(
            [s.text for s in entities.symptoms]
        ) or "See HPI"
        diagnoses_text = ", ".join(
            [d.text for d in entities.diagnoses]
        ) or "To be determined"
        history_text = ", ".join(
            [h.text for h in entities.history]
        ) or "See PMH"

        assessment = self._generate_section(
            ASSESSMENT_TEMPLATE.format(
                symptoms=symptoms_text,
                diagnoses=diagnoses_text,
                history=history_text,
                summary=transcript.full_text[:1000]
            ),
            max_tokens=settings.max_assessment_length
        )

        medications_text = ", ".join(
            [m.text for m in entities.medications]
        ) or "None discussed"
        procedures_text = ", ".join(
            [p.text for p in entities.procedures]
        ) or "None discussed"

        plan = self._generate_section(
            PLAN_TEMPLATE.format(
                medications=medications_text,
                procedures=procedures_text,
                doctor_text=transcript.doctor_text[:1500]
            ),
            max_tokens=settings.max_plan_length
        )

        return SOAPNote(
            subjective=subjective,
            objective=objective,
            assessment=assessment,
            plan=plan,
            encounter_id=encounter_id
        )

    def _generate_section(
        self,
        section_prompt: str,
        max_tokens: int = 300
    ) -> str:
        """Generate a single SOAP section."""
        prompt = (
            f"<|system|>\n{SOAP_SYSTEM_PROMPT}<|end|>\n"
            f"<|user|>\n{section_prompt}<|end|>\n"
            f"<|assistant|>\n"
        )

        response = self.llm(
            prompt,
            max_tokens=max_tokens,
            temperature=settings.slm_temperature,
            stop=["<|end|>", "</s>", "<|user|>"]
        )

        return response["choices"][0]["text"].strip()

┌─────────────────────────────────────────────────────────────────────┐
│ SOAP NOTE FORMAT                                                      │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  S - SUBJECTIVE (Patient's perspective)                             │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ CC: Chest pain x 2 hours                                    │   │
│  │ HPI: 62yo M presenting with substernal chest pain,          │   │
│  │ sharp, radiating to left arm, onset while climbing stairs.  │   │
│  │ Denies SOB, diaphoresis, nausea.                            │   │
│  │ PMH: HTN, DM type 2                                        │   │
│  └─────────────────────────────────────────────────────────────┘   │
│  Source: Patient transcript portions                                │
│                                                                     │
│  O - OBJECTIVE (Physician's observations)                           │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ VS: BP 140/90, HR 88, SpO2 98%, Temp 98.6°F                │   │
│  │ Gen: Alert, in mild distress                                │   │
│  │ CV: RRR, no murmurs                                         │   │
│  │ Lungs: CTA bilaterally                                      │   │
│  └─────────────────────────────────────────────────────────────┘   │
│  Source: Vitals (regex) + physician transcript                      │
│                                                                     │
│  A - ASSESSMENT (Clinical judgment)                                 │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ 1. Chest pain, rule out ACS                                 │   │
│  │ 2. Hypertension, uncontrolled                               │   │
│  │ 3. DM type 2                                                │   │
│  └─────────────────────────────────────────────────────────────┘   │
│  Source: Extracted entities + encounter summary                     │
│                                                                     │
│  P - PLAN (Next steps)                                              │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ 1. STAT ECG, troponin x3 q6h, CBC, BMP                     │   │
│  │ 2. Continue lisinopril, increase to 20mg                    │   │
│  │ 3. Cardiology consult if troponin positive                  │   │
│  │ 4. Follow-up in 1 week                                      │   │
│  └─────────────────────────────────────────────────────────────┘   │
│  Source: Physician plan discussion                                  │
│                                                                     │
│  WHY SECTION-BY-SECTION GENERATION:                                 │
│  • Each section has different source data                           │
│  • Keeps each prompt within SLM context window                     │
│  • Physician can edit individual sections independently             │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/coding/icd10_lookup.py
import sqlite3
from typing import List, Tuple
from dataclasses import dataclass
from sentence_transformers import SentenceTransformer
import numpy as np
from ..config import settings

@dataclass
class ICD10Suggestion:
    """A suggested ICD-10 code."""
    code: str
    description: str
    similarity_score: float
    category: str  # e.g., "I" for circulatory, "J" for respiratory

class ICD10Lookup:
    """Local ICD-10 code lookup using SQLite and embeddings.

    Stores ICD-10 codes with pre-computed embeddings for
    semantic similarity matching. No cloud API needed.
    """

    def __init__(self):
        self.db_path = str(settings.icd10_db_path)
        self.embedding_model = SentenceTransformer(settings.embedding_model)
        self._init_db()

    def _init_db(self):
        """Initialize ICD-10 database schema."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute("""
            CREATE TABLE IF NOT EXISTS icd10_codes (
                code TEXT PRIMARY KEY,
                description TEXT NOT NULL,
                category TEXT,
                embedding BLOB
            )
        """)

        cursor.execute(
            "SELECT COUNT(*) FROM icd10_codes"
        )
        count = cursor.fetchone()[0]

        if count == 0:
            self._seed_common_codes(cursor)
            conn.commit()

        conn.close()

    def _seed_common_codes(self, cursor):
        """Seed database with common ICD-10 codes."""
        common_codes = [
            ("I10", "Essential (primary) hypertension", "I"),
            ("I21.9", "Acute myocardial infarction, unspecified", "I"),
            ("I25.10", "Atherosclerotic heart disease", "I"),
            ("I50.9", "Heart failure, unspecified", "I"),
            ("I48.91", "Unspecified atrial fibrillation", "I"),
            ("E11.9", "Type 2 diabetes mellitus without complications", "E"),
            ("E11.65", "Type 2 DM with hyperglycemia", "E"),
            ("E78.5", "Hyperlipidemia, unspecified", "E"),
            ("J18.9", "Pneumonia, unspecified organism", "J"),
            ("J44.1", "COPD with acute exacerbation", "J"),
            ("J06.9", "Upper respiratory infection", "J"),
            ("R07.9", "Chest pain, unspecified", "R"),
            ("R51.9", "Headache, unspecified", "R"),
            ("R10.9", "Abdominal pain, unspecified", "R"),
            ("R50.9", "Fever, unspecified", "R"),
            ("M54.5", "Low back pain", "M"),
            ("N39.0", "Urinary tract infection", "N"),
            ("K21.0", "GERD with esophagitis", "K"),
            ("F41.1", "Generalized anxiety disorder", "F"),
            ("F32.9", "Major depressive disorder, unspecified", "F"),
            ("G43.909", "Migraine, unspecified", "G"),
            ("J45.20", "Mild intermittent asthma, uncomplicated", "J"),
            ("L30.9", "Dermatitis, unspecified", "L"),
            ("Z00.00", "General adult medical exam", "Z"),
        ]

        for code, description, category in common_codes:
            embedding = self.embedding_model.encode(
                f"{code} {description}"
            )
            cursor.execute(
                "INSERT OR IGNORE INTO icd10_codes "
                "(code, description, category, embedding) "
                "VALUES (?, ?, ?, ?)",
                (code, description, category, embedding.tobytes())
            )

    def suggest_codes(
        self,
        diagnosis_text: str,
        top_k: int = 3
    ) -> List[ICD10Suggestion]:
        """Suggest ICD-10 codes for a diagnosis description."""
        query_embedding = self.embedding_model.encode(diagnosis_text)

        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute(
            "SELECT code, description, category, embedding "
            "FROM icd10_codes"
        )

        results = []
        for code, description, category, emb_bytes in cursor.fetchall():
            doc_embedding = np.frombuffer(emb_bytes, dtype=np.float32)
            similarity = np.dot(query_embedding, doc_embedding) / (
                np.linalg.norm(query_embedding) *
                np.linalg.norm(doc_embedding)
            )
            results.append(ICD10Suggestion(
                code=code,
                description=description,
                similarity_score=float(similarity),
                category=category
            ))

        conn.close()

        results.sort(key=lambda x: x.similarity_score, reverse=True)
        return results[:top_k]

    def get_code(self, code: str) -> ICD10Suggestion:
        """Look up a specific ICD-10 code."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute(
            "SELECT code, description, category "
            "FROM icd10_codes WHERE code = ?",
            (code,)
        )
        row = cursor.fetchone()
        conn.close()

        if row:
            return ICD10Suggestion(
                code=row[0],
                description=row[1],
                similarity_score=1.0,
                category=row[2]
            )
        return None

┌─────────────────────────────────────────────────────────────────────┐
│ SEMANTIC ICD-10 CODE MATCHING                                         │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Input: "chest pain, rule out ACS"                                  │
│         │                                                          │
│         ▼                                                          │
│  Encode with sentence-transformers (384-dim vector)                 │
│         │                                                          │
│         ▼                                                          │
│  Compare against pre-computed ICD-10 embeddings:                    │
│                                                                     │
│  R07.9  "Chest pain, unspecified"          similarity: 0.87 ◄ Top  │
│  I21.9  "Acute myocardial infarction"      similarity: 0.72        │
│  I25.10 "Atherosclerotic heart disease"    similarity: 0.65        │
│  M54.5  "Low back pain"                   similarity: 0.31        │
│                                                                     │
│  WHY LOCAL (not API-based coding):                                  │
│  • Coding APIs expose PHI (diagnosis text)                         │
│  • Local embedding search is fast (<50ms)                       │
│  • Physician always verifies suggested codes                       │
│  • SQLite database can be expanded with facility codes              │
│                                                                     │
│  LIMITATION: 24 common codes in seed data.                          │
│  Production systems should load full ICD-10-CM (~70,000 codes).     │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

# src/export/fhir_exporter.py
from typing import Dict, List, Optional
from datetime import datetime
import json
import uuid
from ..documentation.soap_generator import SOAPNote
from ..extraction.models import ExtractedEntities
from ..coding.icd10_lookup import ICD10Suggestion

class FHIRExporter:
    """Export clinical data as FHIR R4 resources.

    Generates FHIR-compliant JSON for interoperability with
    Electronic Health Record (EHR) systems.

    Produces:
    - Composition (the SOAP note document)
    - Condition (diagnoses with ICD-10 codes)
    - DocumentReference (pointer to the note)
    """

    def __init__(self, practitioner_id: str = "practitioner-001"):
        self.practitioner_id = practitioner_id

    def export_composition(
        self,
        soap_note: SOAPNote,
        patient_id: str,
        encounter_id: str,
        entities: ExtractedEntities,
        icd10_codes: List[ICD10Suggestion] = None
    ) -> Dict:
        """Export SOAP note as FHIR R4 Composition resource."""
        composition_id = str(uuid.uuid4())
        now = datetime.utcnow().isoformat() + "Z"

        composition = {
            "resourceType": "Composition",
            "id": composition_id,
            "status": "preliminary",  # Draft until physician signs
            "type": {
                "coding": [{
                    "system": "http://loinc.org",
                    "code": "11488-4",
                    "display": "Consult note"
                }]
            },
            "subject": {
                "reference": f"Patient/{patient_id}"
            },
            "encounter": {
                "reference": f"Encounter/{encounter_id}"
            },
            "date": now,
            "author": [{
                "reference": f"Practitioner/{self.practitioner_id}"
            }],
            "title": "Clinical Encounter Note",
            "section": [
                {
                    "title": "Subjective",
                    "code": {
                        "coding": [{
                            "system": "http://loinc.org",
                            "code": "61150-9",
                            "display": "Subjective"
                        }]
                    },
                    "text": {
                        "status": "generated",
                        "div": f"<div xmlns='http://www.w3.org/1999/xhtml'>"
                               f"{soap_note.subjective}</div>"
                    }
                },
                {
                    "title": "Objective",
                    "code": {
                        "coding": [{
                            "system": "http://loinc.org",
                            "code": "61149-1",
                            "display": "Objective"
                        }]
                    },
                    "text": {
                        "status": "generated",
                        "div": f"<div xmlns='http://www.w3.org/1999/xhtml'>"
                               f"{soap_note.objective}</div>"
                    }
                },
                {
                    "title": "Assessment",
                    "code": {
                        "coding": [{
                            "system": "http://loinc.org",
                            "code": "51848-0",
                            "display": "Assessment"
                        }]
                    },
                    "text": {
                        "status": "generated",
                        "div": f"<div xmlns='http://www.w3.org/1999/xhtml'>"
                               f"{soap_note.assessment}</div>"
                    }
                },
                {
                    "title": "Plan",
                    "code": {
                        "coding": [{
                            "system": "http://loinc.org",
                            "code": "18776-5",
                            "display": "Plan of care"
                        }]
                    },
                    "text": {
                        "status": "generated",
                        "div": f"<div xmlns='http://www.w3.org/1999/xhtml'>"
                               f"{soap_note.plan}</div>"
                    }
                }
            ]
        }

        # Add conditions from ICD-10 codes
        if icd10_codes:
            conditions = []
            for code in icd10_codes:
                conditions.append(
                    self._create_condition(
                        code, patient_id, encounter_id
                    )
                )
            composition["contained"] = conditions

        return composition

    def _create_condition(
        self,
        icd10: ICD10Suggestion,
        patient_id: str,
        encounter_id: str
    ) -> Dict:
        """Create a FHIR Condition resource from an ICD-10 code."""
        return {
            "resourceType": "Condition",
            "id": str(uuid.uuid4()),
            "clinicalStatus": {
                "coding": [{
                    "system": "http://terminology.hl7.org/CodeSystem/condition-clinical",
                    "code": "active"
                }]
            },
            "code": {
                "coding": [{
                    "system": "http://hl7.org/fhir/sid/icd-10-cm",
                    "code": icd10.code,
                    "display": icd10.description
                }]
            },
            "subject": {
                "reference": f"Patient/{patient_id}"
            },
            "encounter": {
                "reference": f"Encounter/{encounter_id}"
            }
        }

    def export_bundle(
        self,
        soap_note: SOAPNote,
        patient_id: str,
        encounter_id: str,
        entities: ExtractedEntities,
        icd10_codes: List[ICD10Suggestion] = None
    ) -> Dict:
        """Export as a FHIR Bundle containing all resources."""
        composition = self.export_composition(
            soap_note, patient_id, encounter_id, entities, icd10_codes
        )

        bundle = {
            "resourceType": "Bundle",
            "type": "document",
            "timestamp": datetime.utcnow().isoformat() + "Z",
            "entry": [
                {
                    "fullUrl": f"urn:uuid:{composition['id']}",
                    "resource": composition
                }
            ]
        }

        return bundle

    def to_json(self, resource: Dict, pretty: bool = True) -> str:
        """Serialize FHIR resource to JSON."""
        return json.dumps(resource, indent=2 if pretty else None)

# src/export/storage.py
import sqlite3
import json
from typing import List, Optional, Dict
from datetime import datetime
from ..documentation.soap_generator import SOAPNote
from ..config import settings

class EncounterStorage:
    """Local SQLite storage for encounters and notes."""

    def __init__(self):
        self.db_path = str(settings.encounter_db_path)
        self._init_db()

    def _init_db(self):
        """Initialize encounter storage."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute("""
            CREATE TABLE IF NOT EXISTS encounters (
                id TEXT PRIMARY KEY,
                patient_id TEXT NOT NULL,
                soap_subjective TEXT,
                soap_objective TEXT,
                soap_assessment TEXT,
                soap_plan TEXT,
                entities_json TEXT,
                icd10_codes_json TEXT,
                fhir_json TEXT,
                status TEXT DEFAULT 'draft',
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                signed_at TIMESTAMP
            )
        """)

        conn.commit()
        conn.close()

    def save_encounter(
        self,
        encounter_id: str,
        patient_id: str,
        soap_note: SOAPNote,
        entities_json: str = "{}",
        icd10_json: str = "[]",
        fhir_json: str = "{}"
    ):
        """Save an encounter with SOAP note."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute("""
            INSERT OR REPLACE INTO encounters
            (id, patient_id, soap_subjective, soap_objective,
             soap_assessment, soap_plan, entities_json,
             icd10_codes_json, fhir_json)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        """, (
            encounter_id, patient_id,
            soap_note.subjective, soap_note.objective,
            soap_note.assessment, soap_note.plan,
            entities_json, icd10_json, fhir_json
        ))

        conn.commit()
        conn.close()

    def get_encounter(self, encounter_id: str) -> Optional[Dict]:
        """Retrieve an encounter by ID."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        cursor.execute(
            "SELECT * FROM encounters WHERE id = ?",
            (encounter_id,)
        )
        row = cursor.fetchone()
        conn.close()

        if row:
            return {
                "id": row[0],
                "patient_id": row[1],
                "soap": {
                    "subjective": row[2],
                    "objective": row[3],
                    "assessment": row[4],
                    "plan": row[5]
                },
                "entities": json.loads(row[6] or "{}"),
                "icd10_codes": json.loads(row[7] or "[]"),
                "fhir": json.loads(row[8] or "{}"),
                "status": row[9],
                "created_at": row[10],
                "signed_at": row[11]
            }
        return None

    def list_encounters(
        self,
        patient_id: str = None,
        status: str = None,
        limit: int = 20
    ) -> List[Dict]:
        """List encounters with optional filters."""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()

        query = "SELECT id, patient_id, status, created_at FROM encounters"
        params = []
        conditions = []

        if patient_id:
            conditions.append("patient_id = ?")
            params.append(patient_id)
        if status:
            conditions.append("status = ?")
            params.append(status)

        if conditions:
            query += " WHERE " + " AND ".join(conditions)

        query += " ORDER BY created_at DESC LIMIT ?"
        params.append(limit)

        cursor.execute(query, params)
        rows = cursor.fetchall()
        conn.close()

        return [
            {
                "id": r[0],
                "patient_id": r[1],
                "status": r[2],
                "created_at": r[3]
            }
            for r in rows
        ]

# src/app/interface.py
import gradio as gr
import uuid
import json
from ..transcription.whisper_engine import WhisperEngine
from ..extraction.medical_ner import MedicalEntityExtractor
from ..documentation.soap_generator import SOAPGenerator
from ..coding.icd10_lookup import ICD10Lookup
from ..export.fhir_exporter import FHIRExporter
from ..export.storage import EncounterStorage

# Initialize components
whisper = WhisperEngine()
extractor = MedicalEntityExtractor()
soap_gen = SOAPGenerator()
icd10 = ICD10Lookup()
fhir = FHIRExporter()
storage = EncounterStorage()

def process_encounter(audio_file, patient_id):
    """Process a clinical encounter from audio."""
    if not audio_file:
        return "No audio provided", "", "", "", "", ""

    encounter_id = str(uuid.uuid4())[:8]

    # Step 1: Transcribe
    transcript = whisper.transcribe(audio_file)
    transcript_text = transcript.full_text

    # Step 2: Extract entities
    entities = extractor.extract(transcript_text)

    # Step 3: Generate SOAP note
    soap_note = soap_gen.generate(transcript, entities, encounter_id)

    # Step 4: Suggest ICD-10 codes
    codes = []
    for dx in entities.diagnoses:
        suggestions = icd10.suggest_codes(dx.text, top_k=2)
        codes.extend(suggestions)

    # Step 5: Export FHIR
    fhir_bundle = fhir.export_bundle(
        soap_note, patient_id or "unknown",
        encounter_id, entities, codes
    )

    # Step 6: Save locally
    storage.save_encounter(
        encounter_id, patient_id or "unknown",
        soap_note,
        entities_json=json.dumps(
            [e.model_dump() for e in entities.symptoms + entities.diagnoses]
        ),
        icd10_json=json.dumps(
            [{"code": c.code, "desc": c.description} for c in codes]
        ),
        fhir_json=json.dumps(fhir_bundle)
    )

    # Format entity display
    entity_display = "**Vitals:**\n"
    for v in entities.vitals:
        flag = " (ABNORMAL)" if v.is_abnormal else ""
        entity_display += f"- {v.name}: {v.value} {v.unit}{flag}\n"
    entity_display += "\n**Symptoms:** "
    entity_display += ", ".join(s.text for s in entities.symptoms) or "None"
    entity_display += "\n\n**Medications:** "
    entity_display += ", ".join(m.text for m in entities.medications) or "None"
    entity_display += "\n\n**Diagnoses:** "
    entity_display += ", ".join(d.text for d in entities.diagnoses) or "None"

    # Format ICD-10 codes
    codes_display = "\n".join(
        f"- **{c.code}**: {c.description} (match: {c.similarity_score:.2f})"
        for c in codes
    ) or "No codes matched"

    return (
        transcript_text,
        entity_display,
        soap_note.full_note,
        codes_display,
        json.dumps(fhir_bundle, indent=2),
        f"Encounter {encounter_id} saved"
    )


def create_interface():
    """Create the medical scribe Gradio interface."""
    with gr.Blocks(title="Medical Scribe") as demo:
        gr.Markdown("# Medical Scribe")
        gr.Markdown(
            "_On-device clinical documentation - "
            "all processing happens locally_"
        )
        gr.Markdown(
            "**Disclaimer:** Generated notes are drafts "
            "for physician review only."
        )

        with gr.Row():
            audio_input = gr.Audio(
                label="Upload Encounter Audio",
                type="filepath",
                sources=["upload", "microphone"]
            )
            patient_id = gr.Textbox(
                label="Patient ID",
                placeholder="Enter patient identifier"
            )

        process_btn = gr.Button("Process Encounter", variant="primary")

        with gr.Tabs():
            with gr.Tab("Transcript"):
                transcript_out = gr.Textbox(
                    label="Transcript", lines=10
                )
            with gr.Tab("Entities"):
                entities_out = gr.Markdown(label="Extracted Entities")
            with gr.Tab("SOAP Note"):
                soap_out = gr.Textbox(label="SOAP Note", lines=15)
            with gr.Tab("ICD-10 Codes"):
                codes_out = gr.Markdown(label="Suggested Codes")
            with gr.Tab("FHIR Export"):
                fhir_out = gr.Code(
                    label="FHIR R4 Bundle", language="json"
                )

        status_out = gr.Textbox(label="Status", interactive=False)

        process_btn.click(
            process_encounter,
            inputs=[audio_input, patient_id],
            outputs=[
                transcript_out, entities_out, soap_out,
                codes_out, fhir_out, status_out
            ]
        )

        gr.Markdown("""
        ### Privacy Notice
        - All processing happens locally on this device
        - Audio is transcribed locally using whisper.cpp
        - No patient data is sent to any external service
        - Encounters are stored in local SQLite database
        """)

    return demo

if __name__ == "__main__":
    demo = create_interface()
    demo.launch(server_name="0.0.0.0", server_port=7860)

# docker-compose.yml
version: '3.8'

services:
  medical-scribe:
    build: .
    ports:
      - "7860:7860"
    volumes:
      - ./models:/app/models
      - ./data:/app/data
    environment:
      - WHISPER_MODEL_PATH=/app/models/ggml-base.en.bin
      - SLM_MODEL_PATH=/app/models/phi-3-mini-4k-instruct.Q4_K_M.gguf

FROM python:3.11-slim

WORKDIR /app

# System dependencies for audio processing
RUN apt-get update && apt-get install -y \
    ffmpeg \
    && rm -rf /var/lib/apt/lists/*

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/

EXPOSE 7860

CMD ["python", "-m", "src.app.interface"]

# build_desktop.py
"""Build standalone desktop application using PyInstaller."""
import PyInstaller.__main__

PyInstaller.__main__.run([
    'src/app/interface.py',
    '--name=MedicalScribe',
    '--onedir',
    '--add-data=models:models',
    '--add-data=data:data',
    '--hidden-import=llama_cpp',
    '--hidden-import=sentence_transformers',
    '--hidden-import=pywhispercpp',
])

# requirements.txt
pywhispercpp>=1.2.0
llama-cpp-python>=0.3.0
sentence-transformers>=3.0.0
gradio>=4.40.0
fastapi>=0.115.0
uvicorn>=0.30.0
pydantic>=2.9.0
pydantic-settings>=2.5.0
numpy>=1.26.0