Modal-only inference: app calls deployed case-forge-serve (v3); drop GPU libs; CPU Space

app.py

@@ -270,6 +270,7 @@ def _chips_html(flags: dict, lang: str, demo: bool) -> str:
         chips.append('<span class="cf-chip ' + cls + '" style="animation-delay:' + delay
                      + '">' + mark + ' ' + labels[key] + '</span>')
     head = '<div class="cf-chips">' + "".join(chips) + '</div>'
+    head += '<div class="cf-demo">⚠ ' + i18n.t("cf.disclaimer", lang) + '</div>'
     if demo:
         head += '<div class="cf-demo">' + i18n.t("cf.demo_note", lang) + '</div>'
     return head

core/infer.py

@@ -1,16 +1,15 @@
 """Inference for the fine-tuned student — short request → full case+note JSON.
 
-Runtime = ZeroGPU in the Space: load Qwen3-4B-Instruct-2507 once and stack the
-published LoRA adapter (the fine-tune is what makes the short prompt expand into
-the whole schema). The actual `.generate` is wrapped with `@gpu` so ZeroGPU
-allocates a GPU per call; locally (no `spaces`, no CUDA) it falls back to a real
-sample case from the corpus so the UI is fully testable without weights.
+Runtime = **Modal** (no ZeroGPU for this project). The Gradio app calls a deployed
+warm Modal class (`case-forge-serve` / `CaseForge`, see `pipeline/serve_modal.py`)
+that holds base Qwen3-4B + the `qwen3-4b-v3` LoRA. Modal creds come from the Space
+secrets (MODAL_TOKEN_ID / MODAL_TOKEN_SECRET). With no creds / on failure it falls
+back to a real sample case so the UI is fully testable offline.
 
 Config (env):
-  CASE_FORGE_BASE      base model id (default Qwen/Qwen3-4B-Instruct-2507)
-  CASE_FORGE_ADAPTER   HF repo id of the published LoRA (empty → base-only)
-  CASE_FORGE_DEMO=1    force the demo sample (no model load)
-  CASE_FORGE_MAX_TOKENS generation cap (default 4096)
+  CASE_FORGE_MODAL_APP   deployed Modal app name (default case-forge-serve)
+  CASE_FORGE_MODAL_CLS   class name (default CaseForge)
+  CASE_FORGE_DEMO=1      force the demo sample (no Modal call)
 """
 
 from __future__ import annotations
@@ -27,79 +26,25 @@ for _p in (str(_ROOT), str(_MONOREPO)):
         sys.path.insert(0, _p)
 
 from data.schema import validate_case                     # noqa: E402
-from pipeline.prompts import Seed, build_minimal_prompt   # noqa: E402
-from shared import gpu                                     # noqa: E402
-
-BASE_MODEL = os.environ.get("CASE_FORGE_BASE", "Qwen/Qwen3-4B-Instruct-2507")
-# Published Case Forge LoRA (Well-Tuned). Override via env if needed.
-ADAPTER_REPO = os.environ.get(
-    "CASE_FORGE_ADAPTER", "build-small-hackathon/case-forge-qwen3-4b").strip()
-MAX_NEW_TOKENS = int(os.environ.get("CASE_FORGE_MAX_TOKENS", "4096"))
+from pipeline.prompts import Seed                          # noqa: E402
+
+MODAL_APP = os.environ.get("CASE_FORGE_MODAL_APP", "case-forge-serve")
+MODAL_CLS = os.environ.get("CASE_FORGE_MODAL_CLS", "CaseForge")
 FORCE_DEMO = os.environ.get("CASE_FORGE_DEMO", "").strip() in ("1", "true", "yes")
 
-_MODEL = None
-_TOK = None
+_CLS = None  # cached Modal class handle
 
 
-def _has_cuda() -> bool:
-    try:
-        import torch
-        return torch.cuda.is_available()
-    except Exception:
-        return False
-
-
-def _ensure_model() -> None:
-    """Lazy-load base + LoRA. Called inside the GPU-allocated context."""
-    global _MODEL, _TOK
-    if _MODEL is not None:
-        return
-    import torch
-    from transformers import AutoModelForCausalLM, AutoTokenizer
-
-    tok = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
-    model = AutoModelForCausalLM.from_pretrained(
-        BASE_MODEL, torch_dtype=torch.bfloat16, device_map="cuda",
-        trust_remote_code=True,
-    )
-    if ADAPTER_REPO:
-        from peft import PeftModel
-        model = PeftModel.from_pretrained(model, ADAPTER_REPO)
-    model.eval()
-    _MODEL, _TOK = model, tok
+def _modal_ready() -> bool:
+    return bool(os.environ.get("MODAL_TOKEN_ID") and os.environ.get("MODAL_TOKEN_SECRET"))
 
 
-@gpu.gpu(duration=120)
-def _generate_raw(messages: list[dict]) -> str:
-    """Run the model on ZeroGPU and return the raw decoded completion."""
-    import torch
-
-    _ensure_model()
-    try:
-        text = _TOK.apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True,
-            enable_thinking=False,
-        )
-    except TypeError:  # base without the enable_thinking kwarg
-        text = _TOK.apply_chat_template(
-            messages, tokenize=False, add_generation_prompt=True,
-        )
-    inputs = _TOK(text, return_tensors="pt").to(_MODEL.device)
-    with torch.no_grad():
-        out = _MODEL.generate(
-            **inputs, max_new_tokens=MAX_NEW_TOKENS,
-            do_sample=True, temperature=0.7, top_p=0.95,
-            pad_token_id=_TOK.pad_token_id or _TOK.eos_token_id,
-        )
-    return _TOK.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
-
-
-def _parse(raw: str) -> dict | None:
-    """Pull the JSON object out of a completion (tolerant of stray prose)."""
-    try:
-        return json.loads(raw[raw.find("{"): raw.rfind("}") + 1])
-    except Exception:
-        return None
+def _cls():
+    global _CLS
+    if _CLS is None:
+        import modal
+        _CLS = modal.Cls.from_name(MODAL_APP, MODAL_CLS)
+    return _CLS
 
 
 # --- demo fallback -------------------------------------------------------
@@ -108,16 +53,12 @@ _DEMO_BANK: dict[str, dict] | None = None
 
 
 def _demo_bank() -> dict[str, dict]:
-    """One valid sample case per language, pulled from the local corpus.
-
-    Lets the whole UI (render, quality badges, export) work with real data when
-    no GPU/model is available — for local smoke tests and screenshots.
-    """
+    """One valid sample case per language from the local corpus — lets the whole
+    UI (render, badges, export) work without Modal (offline/screenshots)."""
     global _DEMO_BANK
     if _DEMO_BANK is not None:
         return _DEMO_BANK
     bank: dict[str, dict] = {}
-    # demo_infer.json is a single PT sample produced by the real model.
     demo = _ROOT / "data" / "synthetic" / "demo_infer.json"
     if demo.exists():
         try:
@@ -126,8 +67,7 @@ def _demo_bank() -> dict[str, dict]:
                 bank[obj.get("language", "pt")] = obj
         except Exception:
             pass
-    # Fill any missing language from the training corpus.
-    for name in ("pairs_v2.jsonl", "pairs.jsonl"):
+    for name in ("pairs_v3.jsonl", "pairs_v2.jsonl", "pairs.jsonl"):
         if len(bank) >= 2:
             break
         path = _ROOT / "data" / "synthetic" / name
@@ -158,10 +98,9 @@ def _demo_result(seed: Seed) -> dict:
 
 def generate(domain: str, topic: str, level: str = "MBA",
              language: str = "pt", theory: str = "") -> dict:
-    """Forge one case+note from a short request.
+    """Forge one case+note from a short request, via the Modal server.
 
-    Returns {obj, valid, errors, warnings, raw, demo}. `obj` is the schema dict
-    (or None if parsing failed). `demo` is True when the sample fallback was used.
+    Returns {obj, valid, errors, warnings, raw, demo}.
     """
     seed = Seed(
         domain=(domain or "administração").strip(),
@@ -171,20 +110,18 @@ def generate(domain: str, topic: str, level: str = "MBA",
         theory=[t.strip() for t in (theory or "").split(",") if t.strip()],
     )
 
-    if FORCE_DEMO or not (gpu._HAS_SPACES or _has_cuda()):
+    if FORCE_DEMO or not _modal_ready():
         return _demo_result(seed)
 
     try:
-        raw = _generate_raw(build_minimal_prompt(seed))
-    except Exception as exc:  # model/GPU failure → don't crash the UI
-        res = _demo_result(seed)
-        res["errors"] = [f"falha na geração: {exc}"] + res["errors"]
-        return res
-
-    obj = _parse(raw)
-    ok, errs, warns = validate_case(obj) if obj else (False, ["parse falhou"], [])
-    return {"obj": obj, "valid": ok, "errors": errs, "warnings": warns,
-            "raw": raw, "demo": False}
+        res = _cls()().generate.remote(seed.__dict__)
+    except Exception as exc:  # Modal unreachable / cold-start failure → don't crash UI
+        out = _demo_result(seed)
+        out["errors"] = [f"falha na geração (Modal): {exc}"] + out["errors"]
+        return out
+
+    res["demo"] = False
+    return res
 
 
 __all__ = ["generate", "Seed"]

data/schema.py

@@ -195,28 +195,28 @@ def validate_case(obj: dict) -> tuple[bool, list[str], list[str]]:
             "idealmente cada objetivo é coberto por ≥1 questão."
         )
 
-    # 2d) Dados com lastro de fonte (soft) — gênero pede evidência sustentada.
+    # 2d) Fontes FABRICADAS (soft) — o gênero NÃO deve inventar citações com
+    # nome de relatório/instituto/ano. Sinalizamos pra o auditor limpar. (Antes
+    # premiávamos "dado com fonte", o que incentivava o modelo a fabricar — invertido.)
     data = case.get("data") or []
-    if data and not any(_looks_sourced(d) for d in data):
+    if any(_looks_fabricated_source(d) for d in data):
         warnings.append(
-            "nenhum item de dados parece citar fonte; no gênero, "
-            "informação é evidência e deve ser sustentada."
+            "algum dado parece citar uma FONTE FABRICADA (ex.: 'Fonte: Relatório …, 2023'); "
+            "números são ilustrativos — remova citações inventadas."
         )
 
     return (len(errors) == 0, errors, warnings)
 
 
-def _looks_sourced(text: str) -> bool:
-    """Heurística leve: o dado parece citar uma fonte (ano, '(Fonte', '%', etc.)."""
+def _looks_fabricated_source(text: str) -> bool:
+    """Heurística: o dado cita uma 'fonte' com cara de inventada (rótulo + ano)."""
     import re
 
     t = text.lower()
-    return bool(
-        re.search(r"\b(19|20)\d{2}\b", t)         # um ano
-        or "fonte" in t or "source" in t
-        or "segundo" in t or "according to" in t
-        or "%" in t
-    )
+    has_cite = ("fonte" in t or "source" in t or "relatório" in t or "report" in t
+                or "pesquisa de mercado" in t or "según" in t)
+    has_year = bool(re.search(r"\b(19|20)\d{2}\b", t))
+    return has_cite and has_year
 
 
 __all__ = ["CASE_SCHEMA", "validate_case"]

pipeline/prompts.py

@@ -42,7 +42,7 @@ Responda APENAS com um objeto JSON, sem markdown, sem comentários, exatamente n
     "protagonist":   "<o decisor que o leitor veste>",
     "decision_point":"<a pergunta concreta que o protagonista PRECISA decidir>",
     "context":       "<organização, setor e atores envolvidos>",
-    "data":          ["<fato objetivo com fonte/ano/número>", "... (>=3)"],
+    "data":          ["<fato quantitativo ilustrativo, em unidade consistente, SEM citação fabricada>", "... (>=3)"],
     "exhibits":      [{"title": "<anexo opcional>", "content": "<tabela/quadro>"}],
     "alternatives":  ["<argumento p/ um caminho>", "<argumento p/ outro>", "... (>=2)"],
     "closing":       "<revisita o dilema NO ponto de decisão — NUNCA revela a escolha>",
@@ -53,7 +53,7 @@ Responda APENAS com um objeto JSON, sem markdown, sem comentários, exatamente n
     "audience":             "<curso, nível e pré-requisitos>",
     "managerial_relevance": "<por que importa pra gestão>",
     "learning_objectives":  ["<objetivo mensurável (verbo de Bloom)>", "... (1 a 4, NUNCA mais de 4)"],
-    "data_sources":         "<de onde vêm os dados do caso>",
+    "data_sources":         "<declare que os números são ILUSTRATIVOS/FICTÍCIOS para fins de ensino>",
     "theoretical_anchor":   ["<teoria/conceito a mobilizar>"],
     "discussion_plan":      [{"block": "<bloco>", "minutes": 10, "activity": "<atividade>"}],
     "discussion_questions": ["<questão alinhada aos objetivos>", "... (>= nº de objetivos)"],
@@ -71,11 +71,29 @@ Regras invioláveis:
    O desfecho (se houver) vai SÓ no "epilogue" da nota de ensino.
 2. NO MÁXIMO 4 objetivos de aprendizagem, cada um mensurável e começando por verbo de Bloom
    (analisar, avaliar, comparar, calcular, propor...).
-3. Cada item de "data" é uma EVIDÊNCIA: traga número, ano ou fonte. Nada de afirmação solta.
-4. As "discussion_questions" cobrem os objetivos — pelo menos uma por objetivo.
-5. O caso é FICÇÃO PLAUSÍVEL e ORIGINAL: invente empresa, pessoas e números coerentes.
+3. NÚMEROS ILUSTRATIVOS, MAS INTERNAMENTE CONSISTENTES (esta é a regra mais importante):
+   - Use SEMPRE as mesmas unidades no caso todo: mensal vs anual, por-unidade vs por-período,
+     a mesma moeda. Se um custo é "por voo/por mês", a receita comparável também é "por voo/por
+     mês" — ou forneça a capacidade/volume para converter. Nunca misture mês e ano para o mesmo item.
+   - TODA CONTA TEM QUE FECHAR. Recalcule antes de escrever: somas, percentuais, margens,
+     crescimento, ratios, payback. Ex.: só existe "payback" se o investimento GERA economia ou
+     receita extra — não calcule payback sobre algo que AUMENTA o custo mensal.
+   - Os números do exhibit/tabela TÊM QUE BATER com os do texto. Nada de três valores diferentes
+     para o mesmo aumento/indicador.
+   - Magnitudes plausíveis para o porte (uma rede de 12 lojas não gasta R$15 mi/ano em mídia digital).
+4. NÃO INVENTE FONTES NEM CITAÇÕES. Proibido "(Fonte: Relatório Interno, 2023)", "Pesquisa de
+   Mercado, 2021", nomes de institutos/órgãos como autoridade. O dado é ilustrativo: se indicar
+   origem, use rótulo genérico e honesto ("dados internos", "estimativa da equipe"), sem
+   relatório/ano/instituição fabricados. Em "data_sources", afirme que os números são
+   ILUSTRATIVOS/FICTÍCIOS para fins de ensino.
+5. O PROTAGONISTA (com nome) aparece JÁ no "hook"/"context" — nunca surge só no fechamento.
+   Use nomes variados e plausíveis (evite repetir sobrenomes).
+6. A "analysis" da nota, se mostrar contas, usa EXATAMENTE os números do caso e os resolve
+   CORRETAMENTE. Confira a aritmética — o professor vai ensinar isso como gabarito.
+7. As "discussion_questions" cobrem os objetivos — pelo menos uma por objetivo.
+8. O caso é FICÇÃO PLAUSÍVEL e ORIGINAL: invente empresa, pessoas e números coerentes.
    Não copie nenhuma organização real específica.
-6. Escreva todo o conteúdo em {lang_name}. Tom narrativo, concreto, sem moralizar."""
+9. Escreva todo o conteúdo em {lang_name}. Tom narrativo, concreto, sem moralizar."""
 
 
 _SEED_EXTRACTION = """\
@@ -164,5 +182,46 @@ Idioma do conteúdo: {lang_name}{theory_line}{style_line}
     ]
 
 
+_AUDIT_SYSTEM = (
+    "Você é um editor-auditor meticuloso de casos de ensino. Sua obsessão é "
+    "CONSISTÊNCIA NUMÉRICA. Você devolve SEMPRE o objeto JSON inteiro corrigido, "
+    "no mesmo formato recebido, sem comentários."
+)
+
+_AUDIT_CHECKLIST = """\
+Audite e CORRIJA o caso+nota abaixo. Reescreva o JSON INTEIRO já corrigido (mesmas chaves).
+Não invente conteúdo novo desnecessário — apenas conserte os defeitos:
+
+1. UNIDADES: todo número numa unidade coerente. Se um item é "por mês", não trate o mesmo
+   valor como anual em outro lugar. Custo "por voo/unidade" só se compara a receita
+   "por voo/unidade" (ou inclua a capacidade/volume p/ converter). Conserte mismatches.
+2. ARITMÉTICA: recalcule somas, %, margens, crescimento, ratios e PAYBACK. Payback só existe
+   se o investimento gera economia ou receita extra — se os números não sustentam, conserte
+   os números OU reescreva a conta corretamente. A "analysis" da nota deve bater com os dados.
+3. EXHIBIT × TEXTO: os números da tabela têm que ser idênticos aos do texto. Um único valor
+   por indicador. Elimine linhas idênticas/padding.
+4. MAGNITUDE: valores plausíveis para o porte descrito. Conserte exageros (ex.: orçamento
+   gigante para empresa pequena).
+5. FONTES: REMOVA toda citação fabricada ("Fonte: Relatório X, 2023", institutos, anos de
+   relatório inventados). Deixe o dado ilustrativo; em "data_sources" diga que os números são
+   ilustrativos/fictícios para ensino.
+6. PROTAGONISTA: o nome aparece no "hook"/"context", não só no fechamento.
+7. NÃO revele a decisão no "closing" (o desfecho fica no "epilogue" da nota).
+
+JSON a auditar:
+"""
+
+
+def build_audit_prompt(pair_obj: dict) -> list[dict]:
+    """Mensagens para o professor AUDITAR e reparar um par caso+nota já gerado —
+    foco em consistência numérica e remoção de fontes fabricadas. Retorna JSON inteiro."""
+    import json as _json
+    payload = _json.dumps(pair_obj, ensure_ascii=False)
+    return [
+        {"role": "system", "content": _AUDIT_SYSTEM},
+        {"role": "user", "content": _AUDIT_CHECKLIST + payload},
+    ]
+
+
 __all__ = ["Seed", "build_generation_prompt", "build_minimal_prompt",
-           "build_seed_extraction_prompt"]
+           "build_seed_extraction_prompt", "build_audit_prompt"]

requirements.txt

@@ -1,22 +1,10 @@
-# Case Forge — HF Space runtime (Gradio app on ZeroGPU)
+# Case Forge — HF Space runtime (Gradio app).
 #
-# The app loads Qwen3-4B-Instruct-2507 + the published Case Forge LoRA adapter
-# in-Space via ZeroGPU. The data pipeline (collect/generate/train) runs on Modal
-# and only needs the extras flagged at the bottom.
+# Inference runs on MODAL (no ZeroGPU for this project): the app calls a deployed
+# warm Modal class (case-forge-serve / CaseForge, see pipeline/serve_modal.py),
+# so the Space itself needs NO GPU libs (torch/transformers/peft) — it just renders
+# and calls Modal. Set MODAL_TOKEN_ID / MODAL_TOKEN_SECRET as Space secrets.
 
-# --- app runtime ---
 gradio>=6
-spaces                 # ZeroGPU (@spaces.GPU) — no-op locally
-transformers>=4.49
-peft>=0.13             # stack the LoRA adapter onto the base
-accelerate>=1
-torch
+modal                  # calls the deployed Modal inference server
 jsonschema>=4          # full structural validation of the output contract
-
-# --- data pipeline only (collect → generate → train; runs on Modal) ---
-# modal
-# requests
-# beautifulsoup4
-# pypdf
-# datasets
-# bitsandbytes

shared/i18n.py

@@ -103,6 +103,10 @@ _T = {
         "en": "Showing a sample case (model not loaded in this environment).",
         "pt": "Exibindo um caso de amostra (modelo não carregado neste ambiente).",
     },
+    "cf.disclaimer": {
+        "en": "Figures are illustrative/fictional — verify them before classroom use.",
+        "pt": "Números são ilustrativos/fictícios — confira antes de usar em aula.",
+    },
 }