build-small-hackathon: initial Gradio + Modal app scaffold

.gitignore

@@ -6,3 +6,7 @@ coverage/
 *.log
 .env*
 !.env.example
+__pycache__/
+*.pyc
+.gradio/
+test-qwen/

app.py

@@ -0,0 +1,192 @@
+import re
+import gradio as gr
+
+from prompts import SYSTEM_PROMPT, PHASE_SWITCH_REMINDER
+from parse_feedback import parse_feedback, render_feedback_table, strip_markdown
+from stt_engine import transcribe
+from llm_engine import chat as llm_chat
+from tts_engine import synthesize
+
+TERMINATE_RE = re.compile(r"(fin\s+de\s+(la\s+)?séance|session\s+terminée)", re.IGNORECASE)
+
+# 7 outputs: chatbot, audio_output, state, feedback_intro, feedback_table, feedback_panel, status
+
+def _idle_feedback():
+    return "", [], gr.update(open=False)
+
+def _show_feedback(state, clean):
+    entries = parse_feedback(clean)
+    table = render_feedback_table(entries) if entries else []
+    intro = clean
+    if "Disse:" in intro:
+        intro = intro.split("Disse:")[0].strip()
+    return intro, table, gr.update(open=True)
+
+def _chat_val(state):
+    return state["messages"]
+
+def _make_audio(audio_bytes):
+    return audio_bytes if audio_bytes else None
+
+def process_turn(audio_path, state):
+    state = dict(state)
+    if not audio_path:
+        yield _chat_val(state), None, state, *_idle_feedback(), ""
+        return
+
+    # 1. STT
+    yield _chat_val(state), None, state, *_idle_feedback(), "🎙 Transcription…"
+    user_text = transcribe(audio_path)
+    if not user_text or len(user_text.strip()) < 2:
+        yield _chat_val(state), None, state, *_idle_feedback(), "⛔ Parlez plus fort ou plus longtemps."
+        return
+
+    state["messages"].append({"role": "user", "content": user_text.strip()})
+
+    if TERMINATE_RE.search(user_text):
+        yield from _end_session(state)
+        return
+
+    # 2. LLM
+    yield _chat_val(state), None, state, *_idle_feedback(), "🧠 Réflexion…"
+    response = llm_chat(state["messages"])
+    if not response:
+        yield _chat_val(state), None, state, *_idle_feedback(), "⛔ Erreur du modèle. Réessayez."
+        return
+
+    clean = strip_markdown(response)
+    state["messages"].append({"role": "assistant", "content": clean})
+
+    # 3. TTS
+    yield _chat_val(state), None, state, *_idle_feedback(), "🔊 Synthèse vocale…"
+    audio_bytes = synthesize(clean)
+
+    yield _chat_val(state), _make_audio(audio_bytes), state, *_idle_feedback(), ""
+
+
+def _end_session(state):
+    state["messages"].append({"role": "user", "content": PHASE_SWITCH_REMINDER})
+
+    yield _chat_val(state), None, state, *_idle_feedback(), "📝 Génération du récapitulatif…"
+    response = llm_chat(state["messages"])
+    if not response:
+        yield _chat_val(state), None, state, *_idle_feedback(), "⛔ Erreur lors de la génération du bilan."
+        return
+
+    clean = strip_markdown(response)
+    state["messages"].append({"role": "assistant", "content": clean})
+    state["phase"] = 2
+
+    intro, table, accordion = _show_feedback(state, clean)
+    audio_bytes = synthesize(intro)
+
+    yield _chat_val(state), _make_audio(audio_bytes), state, intro, table, accordion, ""
+
+
+def end_session_click(state):
+    state = dict(state)
+    yield from _end_session(state)
+
+
+def reset_session():
+    state = {"messages": [], "phase": 1, "turn_count": 0}
+    state["messages"].append({"role": "system", "content": SYSTEM_PROMPT})
+    return [], None, state, *_idle_feedback(), ""
+
+
+# ---- Init state ----
+initial_messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+initial_state = {"messages": list(initial_messages), "phase": 1, "turn_count": 0}
+
+# ---- Gradio UI ----
+custom_css = open("style.css", encoding="utf-8").read()
+
+with gr.Blocks(
+    css=custom_css,
+    title="Patient Virtuel · Hygiéniste Pro",
+    theme=gr.themes.Soft(primary_hue="orange"),
+) as demo:
+    gr.HTML('<div class="atmosphere"></div>')
+
+    gr.Markdown(
+        '<h1 class="app-title" style="text-align:center; font-weight:400; '
+        'font-family:Cormorant Garamond,serif; color:white; margin-bottom:0; '
+        'font-size:28px; letter-spacing:0.02em;">'
+        "Patient Virtuel · Hygiéniste Pro</h1>"
+    )
+
+    state = gr.State(initial_state)
+
+    with gr.Row():
+        with gr.Column(scale=1, min_width=280):
+            audio_input = gr.Audio(
+                sources=["microphone"],
+                type="filepath",
+                show_label=False,
+                show_download_button=False,
+                waveform_options={"waveform_color": "#ff4e00", "show_controls": False},
+            )
+
+            gr.Markdown(
+                '<p style="font-size:13px; color:#888; text-align:center; '
+                'margin-top:4px;">Appuyez pour parler, relâchez pour envoyer</p>'
+            )
+
+            with gr.Row():
+                btn_end = gr.Button("🟠 Terminer la séance", variant="stop", scale=2)
+                btn_clear = gr.Button("🗑 Nouvelle", variant="secondary", scale=1)
+
+            status = gr.Markdown("", elem_id="status-bar")
+
+        with gr.Column(scale=2):
+            chatbot = gr.Chatbot(
+                value=list(initial_messages),
+                type="messages",
+                label="Conversation",
+                height=480,
+                avatar_images=(None, "🤖"),
+                show_copy_button=False,
+                sanitize_html=True,
+                render_markdown=False,
+            )
+
+            audio_output = gr.Audio(
+                label="Réponse audio",
+                autoplay=True,
+                show_download_button=False,
+                interactive=False,
+                waveform_options={"waveform_color": "#ff4e00", "show_controls": False},
+            )
+
+    with gr.Row():
+        feedback_panel = gr.Accordion(
+            label="📋 Récapitulatif de la séance",
+            open=False,
+        )
+        with feedback_panel:
+            feedback_intro = gr.Markdown("")
+            feedback_table = gr.Dataframe(
+                headers=["Disse", "Correction", "Explication"],
+                datatype=["str", "str", "str"],
+                wrap=True,
+                interactive=False,
+                label="Erreurs relevées",
+                show_label=False,
+            )
+
+    gr.Markdown(
+        '<p style="font-size:11px; color:#555; text-align:center; margin-top:16px;">'
+        "License CC-BY-NC 4.0 (Voxtral TTS) — démonstration non-commerciale. "
+        "Modèle: Qwen/Qwen3.6-27B, STT: faster-whisper.</p>"
+    )
+
+    # ---- Event wiring ----
+    outputs = [chatbot, audio_output, state, feedback_intro, feedback_table, feedback_panel, status]
+
+    audio_input.change(fn=process_turn, inputs=[audio_input, state], outputs=outputs)
+    btn_end.click(fn=end_session_click, inputs=[state], outputs=outputs)
+    btn_clear.click(fn=reset_session, inputs=[], outputs=outputs)
+
+# ---- Launch ----
+if __name__ == "__main__":
+    demo.launch(show_api=False)

llm_engine.py

@@ -0,0 +1,40 @@
+import os
+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
+
+
+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
+    )
+    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:
+        dropped = rest.pop(0)
+        total_chars -= len(dropped.get("content", ""))
+    messages[:] = system + rest

modal_app.py

@@ -0,0 +1,181 @@
+import os
+import tempfile
+import soundfile as sf
+import modal
+
+app = modal.App("patient-virtuel")
+
+# ---- Shared volumes for model cache ----
+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",
+    )
+)
+
+HF_QWEN = "Qwen/Qwen3.6-27B"
+GA = 15
+LP = 15
+
+@app.function(
+    image=qwen_image,
+    gpu=modal.gpu.A100(count=1, memory=40),
+    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,
+)
+@modal.web_endpoint(method="POST", label="qwen-chat")
+def qwen_chat(messages: list[dict], token: str | None = None):
+    _check_token(token)
+
+    from vllm import LLM, SamplingParams, TokensPrompt
+
+    llm = LLM(
+        model=HF_QWEN,
+        dtype="bfloat16",
+        max_model_len=32768,
+        trust_remote_code=True,
+    )
+
+    sp = SamplingParams(
+        temperature=0.7,
+        top_p=0.8,
+        top_k=20,
+        max_tokens=512,
+        stop=["</s>", "<|im_end|>"],
+    )
+
+    outputs = llm.chat(
+        messages=messages,
+        sampling_params=sp,
+        use_tqdm=False,
+    )
+
+    text = outputs[0].outputs[0].text.strip()
+
+    # Strip reasoning tokens if present
+    if "<think>" in text:
+        text = text.split("</think>")[-1].strip()
+
+    return {"text": text}
+
+
+# ---- 2. Whisper STT ----
+whisper_image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .pip_install("faster-whisper", "numpy", "soundfile")
+)
+
+@app.function(
+    image=whisper_image,
+    gpu=modal.gpu.A10G(count=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)
+
+    if not audio_bytes:
+        return {"error": "No audio bytes provided"}, 400
+
+    from faster_whisper import WhisperModel
+
+    model = WhisperModel(
+        "large-v3-turbo",
+        device="cuda",
+        compute_type="float16",
+        download_root=CACHE_DIR,
+    )
+
+    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
+
+    segments, info = model.transcribe(
+        path,
+        language="fr",
+        beam_size=5,
+        vad_filter=True,
+        condition_on_previous_text=False,
+    )
+    os.unlink(path)
+
+    text = " ".join(seg.text for seg in segments)
+    return {"text": text.strip()}
+
+
+# ---- 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")

modal_requirements.txt

@@ -0,0 +1,7 @@
+vllm>=0.8.5
+faster-whisper>=1.1
+huggingface-hub>=0.25
+httpx>=0.28
+modal>=0.70
+soundfile>=0.13
+torch>=2.5

parse_feedback.py

@@ -0,0 +1,32 @@
+import re
+
+PATTERN = re.compile(
+    r"Disse:\s*(.+?)\s*Correction:\s*(.+?)\s*Explication:\s*(.+?)(?=\s*Disse:|\s*$)",
+    re.DOTALL | re.IGNORECASE,
+)
+
+def parse_feedback(text: str) -> list[dict]:
+    entries = []
+    for m in PATTERN.finditer(text):
+        entries.append({
+            "disse": m.group(1).strip(),
+            "correction": m.group(2).strip(),
+            "explication": m.group(3).strip(),
+        })
+    return entries
+
+
+def render_feedback_table(entries: list[dict]) -> list[list[str]]:
+    return [[e["disse"], e["correction"], e["explication"]] for e in entries]
+
+
+def strip_markdown(text: str) -> str:
+    text = re.sub(r"\*\*(.+?)\*\*", r"\1", text)
+    text = re.sub(r"\*(.+?)\*", r"\1", text)
+    text = re.sub(r"`(.+?)`", r"\1", text)
+    text = re.sub(r"#{1,6}\s*", "", text)
+    text = re.sub(r"^[-*]\s", "", text, flags=re.MULTILINE)
+    text = re.sub(r"!?\[.*?\]\(.*?\)", "", text)
+    text = text.replace("▌", "")
+    text = text.replace("🤖", "")
+    return text.strip()

prompts.py

@@ -0,0 +1,26 @@
+SYSTEM_PROMPT = """You are a virtual dental patient in a Swiss clinic. The user is your dental hygienist, currently training to improve their professional French.
+
+Phase 1: Voice Roleplay
+Act as a patient undergoing a 60-minute hygiene session. The flow is: Anamnesis -> Scaling (Détartrage) -> Polishing (Polissage) -> Fluoridation.
+Let the user lead the conversation. Do not anticipate their lines.
+Keep your answers highly concise (1-2 short sentences maximum).
+Speak entirely in French.
+Vary your language skills: use Swiss-French regionalisms (septante, huitante, lolette, chanterelle). Occasionally drop in a basic Swiss-German greeting or loanword ("Grüessech", "Merci vielmal").
+Incorporate natural small talk at the beginning or during pauses (weather, public transport, holidays).
+Occasionally ask administrative questions about cost or insurance coverage.
+During the scaling phase, occasionally simulate sudden pain or sensitivity ("Aïe !", "C'est sensible ici") to test their clinical response.
+NEVER break character, offer advice, or correct their French during the roleplay.
+FORMATTING: Do not use emojis, asterisks, bolding, bullet points, or any markdown. Use only plain text and standard punctuation to ensure smooth text-to-speech playback.
+Continue the roleplay until the user explicitly says: "Fin de la séance" or "Session terminée".
+
+Phase 2: Feedback & Recap (Post-Roleplay)
+Trigger this phase ONLY when the user uses one of the termination phrases above.
+Drop the patient persona and act as an expert French language tutor.
+First, respond with exactly two spoken sentences in French: encourage them, then highlight one main area of improvement regarding medical vocabulary or grammar progression.
+Then IMMEDIATELY provide a structured text response with the detailed written breakdown of their mistakes. Do NOT wait for any further prompt. List the errors clearly in plain text (not a markdown table) using this format for each mistake:
+Disse: [What they said in FR]
+Correction: [Correction in FR]
+Explication: [Explanation in FR]
+"""
+
+PHASE_SWITCH_REMINDER = """Reminder: you are now an expert French language tutor providing feedback. Do NOT continue the patient roleplay. Respond with exactly two spoken sentences in French (encouragement + one area of improvement), then immediately provide the structured Disse/Correction/Explication breakdown. Use plain text only — no markdown, no emojis."""

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=5.0,<6.0
+httpx>=0.28,<1.0
+numpy

space_README.md

@@ -0,0 +1,43 @@
+---
+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
+---
+
+# Patient Virtuel · Hygiéniste Pro
+
+A voice-based French practice tool for dental hygienists. Roleplay a 60-minute hygiene session with a Swiss virtual patient, then receive structured grammar and vocabulary feedback.
+
+**Backyard AI** — built for a real learner training at a Swiss clinic.
+
+## How it works
+
+1. Press the mic button and speak in French to the patient
+2. The patient responds naturally, using Swiss-French regionalisms
+3. When you say "Fin de la séance", the app switches to tutor mode
+4. Receive a structured recap with corrections and explanations
+
+## Model credits
+
+- **LLM**: [Qwen/Qwen3.6-27B](https://huggingface.co/Qwen/Qwen3.6-27B) via Modal (A100 GPU) — Apache 2.0
+- **TTS**: [mistralai/Voxtral-4B-TTS-2603](https://huggingface.co/mistralai/Voxtral-4B-TTS-2603) via Mistral API — CC-BY-NC 4.0 (non-commercial demo)
+- **STT**: [faster-whisper-large-v3-turbo](https://github.com/SYSTRAN/faster-whisper) via Modal (A10G GPU) — MIT
+
+## License disclaimer
+
+The TTS model (Voxtral-4B-TTS-2603) is licensed under CC-BY-NC 4.0. This Space is a non-commercial demonstration. All other components are Apache 2.0 or MIT licensed.
+
+## Environment variables
+
+| Variable | Purpose |
+|---|---|
+| `MODAL_ENDPOINT_QWEN` | Modal endpoint for Qwen LLM |
+| `MODAL_ENDPOINT_WHISPER` | Modal endpoint for Whisper STT |
+| `MODAL_AUTH_TOKEN` | Shared auth token (matching Modal's EXPECTED_TOKEN) |
+| `MISTRAL_API_KEY` | Mistral API key for Voxtral TTS |

stt_engine.py

@@ -0,0 +1,23 @@
+import os
+import httpx
+
+MODAL_ENDPOINT = os.environ.get("MODAL_ENDPOINT_WHISPER", "")
+MODAL_AUTH_TOKEN = os.environ.get("MODAL_AUTH_TOKEN", "")
+
+
+def transcribe(audio_path: str) -> str | None:
+    if not MODAL_ENDPOINT:
+        raise RuntimeError("MODAL_ENDPOINT_WHISPER not set")
+
+    with open(audio_path, "rb") as f:
+        audio_bytes = f.read()
+
+    resp = httpx.post(
+        MODAL_ENDPOINT,
+        data={"token": MODAL_AUTH_TOKEN},
+        files={"audio_bytes": audio_bytes},
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    return data.get("text")

style.css

@@ -0,0 +1,156 @@
+:root {
+  --color-bg: #0a0502;
+  --color-accent: #ff4e00;
+  --glass-surface: rgba(255, 80, 20, 0.1);
+  --glass-border: rgba(255, 200, 150, 0.1);
+  --font-serif: "Cormorant Garamond", serif;
+}
+
+html, body {
+  background-color: var(--color-bg) !important;
+  color: #fff !important;
+  font-family: "Inter", ui-sans-serif, system-ui, sans-serif;
+  overflow: hidden;
+  height: 100%;
+}
+
+.gradio-container {
+  max-width: 100% !important;
+  background: transparent !important;
+}
+
+/* Atmosphere gradient behind the app */
+.atmosphere {
+  position: fixed;
+  top: 0; left: 0;
+  width: 100%; height: 100%;
+  background:
+    radial-gradient(circle at 50% 30%, #3a1510 0%, transparent 60%),
+    radial-gradient(circle at 10% 80%, var(--color-accent) 0%, transparent 50%);
+  filter: blur(80px);
+  opacity: 0.6;
+  z-index: -1;
+  animation: pulse 15s ease-in-out infinite alternate;
+  pointer-events: none;
+}
+
+@keyframes pulse {
+  0% { opacity: 0.4; transform: scale(1); }
+  100% { opacity: 0.7; transform: scale(1.1); }
+}
+
+/* Glass card look */
+.glass-card {
+  background: var(--glass-surface) !important;
+  backdrop-filter: blur(40px) !important;
+  border: 1px solid var(--glass-border) !important;
+  box-shadow: 0 20px 50px rgba(0, 0, 0, 0.3) !important;
+  border-radius: 16px !important;
+}
+
+/* Feedback shell */
+.feedback-shell {
+  background: linear-gradient(
+    135deg, rgba(20, 10, 5, 0.95) 0%, rgba(30, 15, 8, 0.9) 100%
+  ) !important;
+  backdrop-filter: blur(60px) !important;
+  border: 1px solid rgba(255, 150, 80, 0.08) !important;
+  box-shadow:
+    0 40px 80px rgba(0, 0, 0, 0.5),
+    0 0 0 1px rgba(255, 255, 255, 0.03) inset,
+    0 1px 0 rgba(255, 200, 150, 0.05) inset !important;
+  border-radius: 16px !important;
+}
+
+/* Recording glow animation */
+@keyframes glow {
+  0% { box-shadow: 0 0 10px rgba(255, 78, 0, 0.3); }
+  100% { box-shadow: 0 0 30px rgba(255, 78, 0, 0.8); }
+}
+
+.recording-glow {
+  animation: glow 1.5s ease-in-out infinite alternate;
+}
+
+/* Brand accent button */
+button.primary, button.variant-primary {
+  background: var(--color-accent) !important;
+  border-color: var(--color-accent) !important;
+  color: #fff !important;
+}
+
+/* Stop button */
+button.variant-stop {
+  background: #8b0000 !important;
+  border-color: #8b0000 !important;
+  color: #fff !important;
+}
+
+/* Status bar */
+#status-bar {
+  color: var(--color-accent);
+  font-size: 14px;
+  font-weight: 500;
+  height: 24px;
+  transition: opacity 0.2s;
+}
+
+/* Chat bubbles */
+.chat-message {
+  border-radius: 12px !important;
+  font-size: 15px !important;
+  line-height: 1.5 !important;
+}
+
+.user-message {
+  background: var(--glass-surface) !important;
+  border: 1px solid var(--glass-border) !important;
+  color: #e0d0c0 !important;
+}
+
+.assistant-message {
+  background: rgba(255, 255, 255, 0.04) !important;
+  border: 1px solid rgba(255, 255, 255, 0.06) !important;
+  color: #f0e8dc !important;
+}
+
+/* Serif for the title only */
+h1, .app-title {
+  font-family: var(--font-serif) !important;
+  font-weight: 400 !important;
+  letter-spacing: 0.02em !important;
+}
+
+/* Dataframe (feedback table) */
+table.dataframe {
+  background: transparent !important;
+  border: none !important;
+}
+
+table.dataframe td, table.dataframe th {
+  background: transparent !important;
+  border-color: rgba(255, 200, 150, 0.1) !important;
+  color: #d0c0b0 !important;
+}
+
+/* Scrollbar styling */
+::-webkit-scrollbar {
+  width: 6px;
+}
+::-webkit-scrollbar-track {
+  background: transparent;
+}
+::-webkit-scrollbar-thumb {
+  background: rgba(255, 78, 0, 0.3);
+  border-radius: 3px;
+}
+::-webkit-scrollbar-thumb:hover {
+  background: rgba(255, 78, 0, 0.5);
+}
+
+/* Accordion */
+.accordion {
+  background: transparent !important;
+  border: 1px solid var(--glass-border) !important;
+  border-radius: 12px !important;
+}

tts_engine.py

@@ -0,0 +1,44 @@
+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"
+
+
+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)
+
+    resp = httpx.post(
+        "https://api.mistral.ai/v1/audio/speech",
+        headers={"Authorization": f"Bearer {MISTRAL_API_KEY}"},
+        json={
+            "model": MODEL,
+            "input": text,
+            "voice": VOICE,
+            "response_format": "wav",
+        },
+        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()
+    return resp.content