build-small-hackathon: switch to modal.asgi_app, fix endpoint body parsing, base64 audio

README.md

@@ -1,20 +1,19 @@
-<div align="center">
-<img width="1200" height="475" alt="GHBanner" src="https://github.com/user-attachments/assets/0aa67016-6eaf-458a-adb2-6e31a0763ed6" />
-</div>
+---
+title: Patient Virtuel · Hygiéniste Pro
+emoji: 🦷
+colorFrom: orange
+colorTo: dark
+sdk: gradio
+sdk_version: 5.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+---
 
-# Run and deploy your AI Studio app
+# Patient Virtuel · Hygiéniste Pro
 
-This contains everything you need to run your app locally.
+Hackathon submission for [build-small-hackathon](https://huggingface.co/build-small-hackathon).
 
-View your app in AI Studio: https://ai.studio/apps/5628e25f-e268-4a5d-9d6d-b6d96c02e6f7
+**Track**: Backyard AI — a real tool for a real learner: a dental hygienist training professional French for a Swiss clinic.
 
-## Run Locally
-
-**Prerequisites:**  Node.js
-
-
-1. Install dependencies:
-   `npm install`
-2. Set the `GEMINI_API_KEY` in [.env.local](.env.local) to your Gemini API key
-3. Run the app:
-   `npm run dev`
+See [`space_README.md`](space_README.md) for the full description.

llm_engine.py

@@ -4,34 +4,30 @@ import httpx
 MODAL_ENDPOINT = os.environ.get("MODAL_ENDPOINT_QWEN", "")
 MODAL_AUTH_TOKEN = os.environ.get("MODAL_AUTH_TOKEN", "")
 
-TRUNCATION_LIMIT = 20_000  # tokens; oldest non-system turns trimmed when exceeded
+TRUNCATION_LIMIT = 20_000
 
 
 def chat(messages: list[dict]) -> str | None:
     if not MODAL_ENDPOINT:
         raise RuntimeError("MODAL_ENDPOINT_QWEN not set")
 
-    # Trim history if too long: keep system prompt + last N turns
     _trim(messages)
 
     resp = httpx.post(
         MODAL_ENDPOINT,
         json={"messages": messages, "token": MODAL_AUTH_TOKEN},
-        timeout=600,  # long timeout for cold starts
+        timeout=600,
     )
     resp.raise_for_status()
     return resp.json().get("text")
 
 
 def _trim(messages: list[dict]):
-    """Drop oldest non-system turns if total tokens exceeds TRUNCATION_LIMIT."""
     if len(messages) < 4:
         return
-    # rough estimate: 1 token ≈ 3.5 chars
     total_chars = sum(len(m.get("content", "")) for m in messages)
     if total_chars < TRUNCATION_LIMIT * 3.5:
         return
-    # keep system prompt, drop oldest user/assistant pairs
     system = [m for m in messages if m.get("role") == "system"]
     rest = [m for m in messages if m.get("role") != "system"]
     while rest and total_chars >= TRUNCATION_LIMIT * 3.5:

modal_app.py

@@ -1,181 +1,113 @@
+import base64
 import os
 import tempfile
-import soundfile as sf
+
 import modal
 
 app = modal.App("patient-virtuel")
 
-# ---- Shared volumes for model cache ----
+# ---- Shared volumes ----
 qwen_vol = modal.Volume.from_name("qwen-cache", create_if_missing=True)
 whisper_vol = modal.Volume.from_name("whisper-cache", create_if_missing=True)
 CACHE_DIR = "/root/.cache/huggingface"
 
-# ---- Auth helper ----
-EXPECTED_TOKEN = os.environ.get("EXPECTED_TOKEN", "")
-
-def _check_token(token: str | None):
-    if not token or token != EXPECTED_TOKEN:
-        raise modal.exception.APIError("Unauthorized")
-
-default_qwen_timeout = 10 * 60  # 10m for cold start + inference
-
 # ---- 1. Qwen/Qwen3.6-27B LLM ----
 qwen_image = (
     modal.Image.debian_slim(python_version="3.12")
-    .pip_install(
-        "vllm>=0.8.5",
-        "huggingface-hub>=0.25",
-        "torch>=2.5",
-    )
+    .pip_install("vllm>=0.6.0", "bitsandbytes>=0.43", "huggingface-hub", "torch>=2.5", "fastapi[standard]")
 )
 
-HF_QWEN = "Qwen/Qwen3.6-27B"
-GA = 15
-LP = 15
 
 @app.function(
     image=qwen_image,
-    gpu=modal.gpu.A100(count=1, memory=40),
+    gpu="A100:1",
     volumes={CACHE_DIR: qwen_vol},
-    secrets=[modal.Secret.from_name("hf-token")],
-    timeout=default_qwen_timeout,
-    scaledown_window=600,  # keep warm 10 min after last call
-    concurrency_limit=1,
-    container_idle_timeout=600,
+    secrets=[modal.Secret.from_name("hf-token"), modal.Secret.from_name("app-tokens")],
+    timeout=600,
+    scaledown_window=600,
 )
-@modal.web_endpoint(method="POST", label="qwen-chat")
-def qwen_chat(messages: list[dict], token: str | None = None):
-    _check_token(token)
+@modal.asgi_app()
+def qwen_web():
+    from fastapi import FastAPI, HTTPException, Request
+
+    fastapi_app = FastAPI()
 
-    from vllm import LLM, SamplingParams, TokensPrompt
+    @fastapi_app.post("/")
+    async def handler(request: Request):
+        body = await request.json()
+        token = body.get("token", "")
+        expected = os.environ.get("EXPECTED_TOKEN", "")
+        if not token or token != expected:
+            raise HTTPException(401, "Unauthorized")
 
-    llm = LLM(
-        model=HF_QWEN,
-        dtype="bfloat16",
-        max_model_len=32768,
-        trust_remote_code=True,
-    )
+        messages = body["messages"]
 
-    sp = SamplingParams(
-        temperature=0.7,
-        top_p=0.8,
-        top_k=20,
-        max_tokens=512,
-        stop=["</s>", "<|im_end|>"],
-    )
+        from vllm import LLM, SamplingParams
 
-    outputs = llm.chat(
-        messages=messages,
-        sampling_params=sp,
-        use_tqdm=False,
-    )
+        llm = LLM(
+            model="Qwen/Qwen3.6-27B",
+            dtype="bfloat16",
+            quantization="bitsandbytes",
+            load_format="bitsandbytes",
+            max_model_len=16384,
+            trust_remote_code=True,
+        )
 
-    text = outputs[0].outputs[0].text.strip()
+        sp = SamplingParams(temperature=0.7, top_p=0.8, top_k=20, max_tokens=512)
+        outputs = llm.chat(messages=messages, sampling_params=sp, use_tqdm=False)
 
-    # Strip reasoning tokens if present
-    if "<think>" in text:
-        text = text.split("</think>")[-1].strip()
+        text = outputs[0].outputs[0].text.strip()
+        if "<think>" in text:
+            text = text.split("</think>")[-1].strip()
+        return {"text": text}
 
-    return {"text": text}
+    return fastapi_app
 
 
-# ---- 2. Whisper STT ----
+# ---- 2. Whisper STT (JSON input — base64-encoded WAV) ----
 whisper_image = (
     modal.Image.debian_slim(python_version="3.12")
-    .pip_install("faster-whisper", "numpy", "soundfile")
+    .pip_install("faster-whisper", "numpy", "fastapi[standard]")
 )
 
+
 @app.function(
     image=whisper_image,
-    gpu=modal.gpu.A10G(count=1),
+    gpu="A10G:1",
     volumes={CACHE_DIR: whisper_vol},
     timeout=120,
     scaledown_window=300,
-    concurrency_limit=1,
-    container_idle_timeout=300,
 )
-@modal.web_endpoint(method="POST", label="whisper-stt")
-def whisper_stt(token: str | None = None, audio_bytes: bytes | None = None):
-    _check_token(token)
+@modal.asgi_app()
+def whisper_web():
+    from fastapi import FastAPI, HTTPException, Request
 
-    if not audio_bytes:
-        return {"error": "No audio bytes provided"}, 400
+    fastapi_app = FastAPI()
 
-    from faster_whisper import WhisperModel
+    @fastapi_app.post("/")
+    async def handler(request: Request):
+        body = await request.json()
+        token = body.get("token", "")
+        expected = os.environ.get("EXPECTED_TOKEN", "")
+        if not token or token != expected:
+            raise HTTPException(401, "Unauthorized")
 
-    model = WhisperModel(
-        "large-v3-turbo",
-        device="cuda",
-        compute_type="float16",
-        download_root=CACHE_DIR,
-    )
+        audio_base64 = body["audio_base64"]
 
-    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
-        f.write(audio_bytes if isinstance(audio_bytes, bytes) else audio_bytes.encode("latin1"))
-        path = f.name
+        from faster_whisper import WhisperModel
 
-    segments, info = model.transcribe(
-        path,
-        language="fr",
-        beam_size=5,
-        vad_filter=True,
-        condition_on_previous_text=False,
-    )
-    os.unlink(path)
+        model = WhisperModel(
+            "large-v3-turbo", device="cuda", compute_type="float16", download_root=CACHE_DIR,
+        )
 
-    text = " ".join(seg.text for seg in segments)
-    return {"text": text.strip()}
+        raw = base64.b64decode(audio_base64)
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+            f.write(raw)
+            path = f.name
 
+        segments, _ = model.transcribe(path, language="fr", beam_size=5, vad_filter=True)
+        os.unlink(path)
 
-# ---- 3. Mistral API TTS (wrapped for unified call from Space) ----
-@app.function(
-    image=modal.Image.debian_slim(python_version="3.12").pip_install("httpx"),
-    secrets=[modal.Secret.from_name("mistral-key")],
-    timeout=30,
-    scaledown_window=60,
-)
-@modal.web_endpoint(method="POST", label="mistral-tts")
-def mistral_tts(text: str, token: str | None = None):
-    _check_token(token)
-
-    import httpx as _httpx
-
-    api_key = os.environ.get("MISTRAL_API_KEY", "")
-    if not api_key:
-        return {"error": "MISTRAL_API_KEY not set"}, 500
-
-    resp = _httpx.post(
-        "https://api.mistral.ai/v1/audio/speech",
-        headers={"Authorization": f"Bearer {api_key}"},
-        json={
-            "model": "mistral-tts",  # TODO: confirm exact model name on Mistral API
-            "input": text,
-            "voice": "french_female",
-            "response_format": "wav",
-        },
-        timeout=25,
-    )
-    resp.raise_for_status()
-    return resp.content  # raw WAV bytes
-
-
-# ---- Local dev helper ----
-@app.local_entrypoint()
-def test():
-    import httpx
-
-    print("Testing Qwen endpoint...")
-    r = httpx.post(
-        "http://localhost:8000/qwen-chat",
-        json={"messages": [{"role": "user", "content": "Dis bonjour en français"}], "token": EXPECTED_TOKEN},
-        timeout=30,
-    )
-    print(f"Qwen: {r.json()}")
-
-    print("Testing Mistral TTS endpoint...")
-    r = httpx.post(
-        "http://localhost:8000/mistral-tts",
-        json={"text": "Bonjour, comment allez-vous?", "token": EXPECTED_TOKEN},
-        timeout=30,
-    )
-    print(f"TTS: {len(r.content)} bytes")
+        return {"text": " ".join(s.text for s in segments)}
+
+    return fastapi_app

stt_engine.py

@@ -1,3 +1,4 @@
+import base64
 import os
 import httpx
 
@@ -10,14 +11,12 @@ def transcribe(audio_path: str) -> str | None:
         raise RuntimeError("MODAL_ENDPOINT_WHISPER not set")
 
     with open(audio_path, "rb") as f:
-        audio_bytes = f.read()
+        b64 = base64.b64encode(f.read()).decode()
 
     resp = httpx.post(
         MODAL_ENDPOINT,
-        data={"token": MODAL_AUTH_TOKEN},
-        files={"audio_bytes": audio_bytes},
+        json={"audio_base64": b64, "token": MODAL_AUTH_TOKEN},
         timeout=30,
     )
     resp.raise_for_status()
-    data = resp.json()
-    return data.get("text")
+    return resp.json().get("text")

tts_engine.py

@@ -1,21 +1,18 @@
 import os
 import httpx
 
-MODAL_ENDPOINT = os.environ.get("MODAL_ENDPOINT_MISTRAL_TTS", "")
 MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY", "")
-MODAL_AUTH_TOKEN = os.environ.get("MODAL_AUTH_TOKEN", "")
-
-VOICE = "french_female"
-MODEL = "mistral-tts"
+VOICE = os.environ.get("TTS_VOICE", "french_female")
+MODEL = os.environ.get("TTS_MODEL", "mistral-tts")
+API_URL = "https://api.mistral.ai/v1/audio/speech"
 
 
 def synthesize(text: str) -> bytes | None:
-    """Tier-1: call Mistral API directly from the Space (simplest, free tier)."""
     if not MISTRAL_API_KEY:
-        return _fallback_modal(text)
+        raise RuntimeError("MISTRAL_API_KEY not set")
 
     resp = httpx.post(
-        "https://api.mistral.ai/v1/audio/speech",
+        API_URL,
         headers={"Authorization": f"Bearer {MISTRAL_API_KEY}"},
         json={
             "model": MODEL,
@@ -26,19 +23,5 @@ def synthesize(text: str) -> bytes | None:
         timeout=25,
     )
     if resp.is_error:
-        return _fallback_modal(text)
-    return resp.content
-
-
-def _fallback_modal(text: str) -> bytes | None:
-    """Tier-2: fall back to Modal-hosted Mistral TTS."""
-    if not MODAL_ENDPOINT:
-        raise RuntimeError("No TTS endpoint available")
-
-    resp = httpx.post(
-        MODAL_ENDPOINT,
-        json={"text": text, "token": MODAL_AUTH_TOKEN},
-        timeout=30,
-    )
-    resp.raise_for_status()
+        raise RuntimeError(f"Mistral TTS error: {resp.status_code} {resp.text}")
     return resp.content