Rebuild as Spruce: AI-native CRM for a health coach

Two small models on Modal: MiniCPM3-4B routes updates to the right client,
extracts a structured record, classifies the pipeline stage, and harvests
reusable methods; Nemotron-3-Nano-4B answers questions over the client data
and writes grounded briefs. Custom cockpit UI with a command bar, stage board,
recency timeline, and a Needs-attention panel.

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+*.db
+IDEATION.md

README.md

@@ -1,15 +1,77 @@
 ---
-title: MiniRobot
-emoji: 😻
-colorFrom: red
-colorTo: yellow
+title: Spruce
+emoji: 🌲
+colorFrom: green
+colorTo: blue
 sdk: gradio
 sdk_version: 6.17.3
 python_version: '3.12'
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: 'small VLM judging robot manipulation  - MiniCPM-V + GVL '
+short_description: 'AI-native CRM you talk to, powered by small models'
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Spruce
+
+An agent-native CRM for a health coach who runs message-based coaching with the
+occasional checkup call. It does two jobs, each with a genuinely small model:
+
+1. **Structure every client.** Paste anything a client sent (a message thread, a
+   call note, an intake) and **MiniCPM3-4B** (OpenBMB, 4B) turns it into a
+   structured record: goals and current protocol, history of what was tried,
+   flags to watch, and open follow-ups. It also harvests any reusable method the
+   coach stated, growing a knowledgebase that starts empty.
+
+2. **Brief the coach before they reply.** Cornerman retrieves the relevant
+   knowledgebase entries and **Nemotron-3-Nano-4B** (NVIDIA, 4B) writes a short
+   brief: which of the coach's own methods apply, what was already tried, what to
+   watch for. The coach writes the actual message.
+
+## Honest small-model fit
+
+Neither model does medicine. One restructures natural language into a record.
+The other reasons over text the coach supplied (the client's record and the
+coach's own knowledgebase) and is told never to introduce outside clinical
+claims. Both tasks are squarely what small instruction-tuned models do well,
+which keeps the small-model story honest.
+
+The brief always ends with "Not medical advice. Coach reviews before sending,"
+and nothing is ever sent to a client automatically.
+
+## Two models, two jobs
+
+| Job | Model | Why this model |
+| --- | --- | --- |
+| Extract + harvest | `openbmb/MiniCPM3-4B` | Strong at format-following and JSON output |
+| Coaching brief | `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16` | Built for compact agentic reasoning |
+
+Both are 4B or under. They need different `transformers` versions, so the
+backend runs them as two separate Modal services, each warm-loaded and scaling
+to zero between calls.
+
+## How it works
+
+- **Frontend (this Space):** `app.py`. A custom Gradio cockpit: client list,
+  per-client record, paste-to-ingest, a knowledgebase panel, and a "Brief me"
+  flow. It owns the data (SQLite) and the keyword retrieval; the models stay
+  stateless.
+- **Model backend:** `modal_app.py`. Two Modal GPU services exposing small HTTP
+  endpoints for extraction, harvesting, and briefing.
+
+## Running it
+
+Backend:
+
+```
+modal deploy modal_app.py     # prints two web endpoint URLs
+```
+
+Then set two Space secrets to those URLs:
+
+```
+EXTRACT_URL   ->  the Extractor.web URL  (MiniCPM3-4B)
+COACH_URL     ->  the Coach.web URL      (Nemotron-3-Nano-4B)
+```
+
+Built for the build-small-hackathon. Models by OpenBMB and NVIDIA, GPUs by Modal.

app.py

@@ -1,170 +1,544 @@
 """
-Build Small hackathon starter: sub-32B VLM as a training-free judge for robot manipulation.
-
-What it does
-------------
-Given a manipulation episode (a list of frames + a task description), it uses MiniCPM-V to
-estimate per-frame task progress (0-100) using the GVL trick (shuffle frames so the model
-can't just copy temporal order), then:
-  - plots the progress curve,
-  - derives a success verdict from late-stage progress,
-  - reports Value-Order Correlation (VOC) = rank corr between predicted progress and true
-    chronological order. High VOC means the model actually understands task progression.
-
-Method reference: Ma et al., "Vision Language Models are In-Context Value Learners" (GVL),
-arXiv 2411.04549. VOC and the shuffled-frame formulation are from that paper.
-
-Notes
------
-- The MiniCPM-V call signature can change between versions. Verify against the current model
-  card at https://huggingface.co/openbmb/MiniCPM-V-4_5 before relying on it.
-- Use MiniCPM-V-4.6 for local dev on 8GB VRAM, MiniCPM-V-4_5 (8B) on ZeroGPU/Modal
-  for the real numbers. The 4.5-vs-4.6 gap is your headline finding.
-- This is a scaffold. The parts that matter (GVL scoring, VOC) are correct; the model I/O is
-  where you should expect to adjust.
+Spruce: an AI-native CRM a health coach talks to instead of maintaining a board.
+
+The coach types (later: speaks) one line into the command bar. Spruce decides
+whether it is an update or a question:
+
+  * Update  -> MiniCPM3-4B (on Modal) routes it to the right client (creating one
+    if needed), extracts a structured record, classifies the pipeline stage, and
+    logs a dated timeline event. It also harvests any reusable method the coach
+    stated, to grow a knowledgebase.
+  * Question -> Nemotron-3-Nano-4B (on Modal) answers from the client data
+    ("what's the update on Max?", "who have I not contacted lately?").
+
+A "Needs attention" panel surfaces stale clients and open follow-ups so nothing
+is dropped. A stage board gives the visual overview as a secondary view. The
+models never message a client and never invent clinical claims.
+
+Two endpoints, both from modal_app.py:
+  EXTRACT_URL : MiniCPM3-4B          (route / extract / harvest)
+  COACH_URL   : Nemotron-3-Nano-4B   (answer / brief)
+Set them as Space secrets in production.
 """
 
-import random
-import numpy as np
-from PIL import Image
-from scipy.stats import spearmanr
+import datetime as dt
+import json
+import os
+import re
+import sqlite3
+
 import gradio as gr
+import requests
 
-# ZeroGPU: the decorator moves work onto a GPU slice on Spaces. Harmless to import locally.
-try:
-    import spaces
+EXTRACT_URL = os.environ.get("EXTRACT_URL", "").rstrip("/")
+COACH_URL = os.environ.get("COACH_URL", "").rstrip("/")
+DB_PATH = os.environ.get("CORNERMAN_DB", "spruce.db")
+STALE_DAYS = int(os.environ.get("SPRUCE_STALE_DAYS", "7"))
 
-    GPU = spaces.GPU
-except Exception:  # local dev without the spaces package
+STAGES = [
+    "Discovery Call",
+    "Customer booked",
+    "Analysis call",
+    "Second call",
+    "Weeks 1-4",
+    "Weeks 5-8",
+]
 
-    def GPU(*a, **k):
-        def wrap(fn):
-            return fn
+EMPTY_RECORD = {
+    "stage": "",
+    "goals": "",
+    "current_protocol": "",
+    "next_step": "",
+    "flags": [],
+    "follow_ups": [],
+}
 
-        return wrap if (a and callable(a[0]) is False) else (a[0] if a else None)
+_STOP = set(
+    "the a an and or of to in on for with is are was were be been being this that "
+    "these those it its as at by from he she they you i we client coach about into "
+    "after before over under more most some any not no do does did has have had will "
+    "would can could should still your their them his her my our up out".split()
+)
 
 
-import torch
-from transformers import AutoModel, AutoTokenizer
+def _today():
+    return dt.date.today().isoformat()
 
-MODEL_ID = "openbmb/MiniCPM-V-4_5"  # swap to openbmb/MiniCPM-V-4.6 for the smaller local run
-N_FRAMES = 16
-SUCCESS_THRESHOLD = (
-    70.0  # late-stage progress above this counts as success; tune on your data
-)
 
-_model = None
-_tokenizer = None
+# ---------------------------------------------------------------------------
+# Storage.
+# ---------------------------------------------------------------------------
+def _conn():
+    c = sqlite3.connect(DB_PATH)
+    c.row_factory = sqlite3.Row
+    return c
+
+
+def db_init():
+    with _conn() as c:
+        c.execute(
+            "CREATE TABLE IF NOT EXISTS clients ("
+            "id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, record TEXT, "
+            "customer_since TEXT, last_contacted TEXT, timeline TEXT)"
+        )
+        c.execute(
+            "CREATE TABLE IF NOT EXISTS kb ("
+            "id INTEGER PRIMARY KEY AUTOINCREMENT, title TEXT, body TEXT)"
+        )
+        n = c.execute("SELECT COUNT(*) AS n FROM clients").fetchone()["n"]
+        if n == 0:
+            _seed(c)
+
+
+def _seed(c):
+    samples = [
+        (
+            "Sample: Dana R.",
+            {
+                "stage": "Weeks 1-4",
+                "goals": "Steady afternoon energy, lose 4kg in 12 weeks.",
+                "current_protocol": "16:8 window, 3 strength sessions a week.",
+                "next_step": "Review sleep log on next check-in.",
+                "flags": ["Knees sore after lunges, ease lower-body volume."],
+                "follow_ups": ["Check sleep again next week."],
+            },
+            "2026-05-20",
+            "2026-06-03",
+            [
+                {"date": "2026-05-20", "event": "Started Weeks 1-4 block."},
+                {"date": "2026-06-03", "event": "Reported 3pm energy crash and poor sleep."},
+            ],
+        ),
+        (
+            "Sample: Sam P.",
+            {
+                "stage": "Discovery Call",
+                "goals": "Explore working together on stress and digestion.",
+                "current_protocol": "",
+                "next_step": "Send booking link for analysis call.",
+                "flags": [],
+                "follow_ups": ["Waiting on Sam to pick a time."],
+            },
+            "2026-06-08",
+            "2026-06-08",
+            [{"date": "2026-06-08", "event": "Discovery call held, interested but undecided."}],
+        ),
+    ]
+    for name, rec, since, last, tl in samples:
+        c.execute(
+            "INSERT INTO clients (name, record, customer_since, last_contacted, timeline) "
+            "VALUES (?, ?, ?, ?, ?)",
+            (name, json.dumps(rec), since, last, json.dumps(tl)),
+        )
+
+
+def list_clients():
+    with _conn() as c:
+        return [r["name"] for r in c.execute("SELECT name FROM clients ORDER BY name")]
+
+
+def get_client(name):
+    with _conn() as c:
+        row = c.execute("SELECT * FROM clients WHERE name = ?", (name,)).fetchone()
+    if not row:
+        return None
+    return {
+        "name": row["name"],
+        "record": _loads(row["record"], dict(EMPTY_RECORD)),
+        "customer_since": row["customer_since"] or "",
+        "last_contacted": row["last_contacted"] or "",
+        "timeline": _loads(row["timeline"], []),
+    }
+
+
+def all_clients():
+    return [get_client(n) for n in list_clients()]
+
 
+def _loads(s, default):
+    try:
+        v = json.loads(s)
+        return v if v is not None else default
+    except (TypeError, json.JSONDecodeError):
+        return default
 
-def _load():
-    global _model, _tokenizer
-    if _model is None:
-        _tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
-        _model = (
-            AutoModel.from_pretrained(
-                MODEL_ID,
-                trust_remote_code=True,
-                torch_dtype=torch.bfloat16,
-                attn_implementation="sdpa",
+
+def ensure_client(name):
+    name = (name or "").strip() or "Unsorted client"
+    with _conn() as c:
+        row = c.execute("SELECT name FROM clients WHERE name = ?", (name,)).fetchone()
+        if not row:
+            c.execute(
+                "INSERT INTO clients (name, record, customer_since, last_contacted, timeline) "
+                "VALUES (?, ?, ?, ?, ?)",
+                (name, json.dumps(EMPTY_RECORD), _today(), "", json.dumps([])),
             )
-            .eval()
-            .cuda()
+    return name
+
+
+def save_update(name, record, event):
+    """Persist a record update, append a dated timeline event, stamp contact date."""
+    cur = get_client(name)
+    timeline = cur["timeline"] if cur else []
+    today = _today()
+    if event:
+        timeline = timeline + [{"date": today, "event": event}]
+    since = (cur["customer_since"] if cur and cur["customer_since"] else today)
+    with _conn() as c:
+        c.execute(
+            "UPDATE clients SET record = ?, last_contacted = ?, customer_since = ?, "
+            "timeline = ? WHERE name = ?",
+            (json.dumps(record, ensure_ascii=False), today, since,
+             json.dumps(timeline, ensure_ascii=False), name),
+        )
+
+
+def list_kb():
+    with _conn() as c:
+        return [
+            {"id": r["id"], "title": r["title"], "body": r["body"]}
+            for r in c.execute("SELECT id, title, body FROM kb ORDER BY id DESC")
+        ]
+
+
+def add_kb(title, body):
+    title, body = (title or "").strip(), (body or "").strip()
+    if title and body:
+        with _conn() as c:
+            c.execute("INSERT INTO kb (title, body) VALUES (?, ?)", (title, body))
+
+
+# ---------------------------------------------------------------------------
+# Modal calls (requests follows Modal's 303 long-poll redirect by default).
+# ---------------------------------------------------------------------------
+def _post(url, payload):
+    if not url:
+        raise RuntimeError(
+            "Model endpoint not set. Deploy modal_app.py and set EXTRACT_URL and "
+            "COACH_URL (Space secrets in production)."
         )
-    return _model, _tokenizer
+    r = requests.post(url, json=payload, timeout=300)
+    r.raise_for_status()
+    return r.json()
 
 
-def sample_frames(frames, n=N_FRAMES):
-    """Uniformly sample n frames from a list of PIL images."""
-    if len(frames) <= n:
-        return list(range(len(frames))), frames
-    idx = np.linspace(0, len(frames) - 1, n).astype(int).tolist()
-    return idx, [frames[i] for i in idx]
+def _strip_think(text):
+    """Nemotron is a reasoning model; drop any <think>...</think> it emits."""
+    text = text or ""
+    if "</think>" in text:
+        text = text.split("</think>")[-1]
+    return text.strip()
 
 
-def _ask_progress(model, tokenizer, task, init_frame, query_frame):
-    """One VLM call: given the initial frame as the 0% reference, score one query frame."""
-    prompt = (
-        f"A robot is performing this task: {task}.\n"
-        f"The first image is the initial state (0% complete).\n"
-        f"The second image is a frame from somewhere in the episode (order unknown).\n"
-        f"Estimate how complete the task is in the second image, as a single integer 0-100. "
-        f"Reply with the number only."
+def _words(text):
+    return {w for w in re.findall(r"[a-z]{3,}", (text or "").lower()) if w not in _STOP}
+
+
+def retrieve_kb(record, k=4):
+    entries = list_kb()
+    if not entries:
+        return []
+    rec_text = " ".join(
+        [record.get("goals", ""), record.get("current_protocol", ""), record.get("next_step", "")]
+        + record.get("flags", []) + record.get("follow_ups", [])
     )
-    msgs = [{"role": "user", "content": [init_frame, query_frame, prompt]}]
-    out = model.chat(
-        image=None, msgs=msgs, tokenizer=tokenizer
-    )  # verify signature per model card
-    digits = "".join(c for c in str(out) if c.isdigit())
-    if not digits:
-        return 0.0
-    return float(max(0, min(100, int(digits[:3]))))
-
-
-@GPU(duration=120)
-def score_episode(frames, task):
-    """GVL-style scoring. Returns (chronological progress list, VOC)."""
-    model, tokenizer = _load()
-    _, sampled = sample_frames(frames)
-    init = sampled[0]
-    rest = list(enumerate(sampled))[1:]  # (true_chrono_index, frame)
-
-    shuffled = rest[:]
-    random.shuffle(shuffled)  # the GVL trick: break temporal adjacency
-
-    scored = {}
-    for true_idx, frame in shuffled:
-        scored[true_idx] = _ask_progress(model, tokenizer, task, init, frame)
-
-    progress = [0.0] + [scored[i] for i, _ in rest]  # restore chronological order
-    true_order = list(range(len(progress)))
-    voc, _ = spearmanr(progress, true_order)
-    return progress, float(voc)
-
-
-def run(video_frames_dir_or_list, task):
-    """Gradio entry. Expects a list of PIL frames; adapt to your loader (lerobot / decord)."""
-    frames = video_frames_dir_or_list  # TODO: plug your LeRobot/LIBERO/OXE episode loader here
-    if not frames:
-        return None, "No frames loaded.", None
-    progress, voc = score_episode(frames, task)
-    late = np.mean(progress[-3:]) if len(progress) >= 3 else progress[-1]
-    verdict = "SUCCESS" if late >= SUCCESS_THRESHOLD else "FAILURE"
-
-    import matplotlib.pyplot as plt
-
-    fig, ax = plt.subplots(figsize=(6, 3))
-    ax.plot(range(len(progress)), progress, marker="o")
-    ax.set_xlabel("frame (chronological)")
-    ax.set_ylabel("predicted progress (%)")
-    ax.set_ylim(-5, 105)
-    ax.set_title(f"VOC = {voc:.2f}")
-    fig.tight_layout()
-
-    summary = f"Verdict: {verdict}\nLate-stage progress: {late:.0f}%\nVOC: {voc:.2f}"
-    return fig, summary, voc
-
-
-with gr.Blocks(title="Can a small VLM judge robot success?") as demo:
-    gr.Markdown(
-        "## Small VLM as a training-free robot judge\n"
-        "Upload or pick a manipulation episode. The model estimates task progress per frame "
-        "(GVL shuffled-frame method) and reports VOC and a success verdict."
+    rw = _words(rec_text)
+    scored = sorted(
+        ((len(rw & _words(e["title"] + " " + e["body"])), e) for e in entries),
+        key=lambda t: t[0], reverse=True,
     )
-    with gr.Row():
-        with gr.Column():
-            task_in = gr.Textbox(
-                label="Task description", value="put the red block in the bowl"
+    top = [e for s, e in scored if s > 0][:k]
+    return top or [e for _, e in scored][:k]
+
+
+def _days_since(iso):
+    try:
+        return (dt.date.today() - dt.date.fromisoformat(iso)).days
+    except (TypeError, ValueError):
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Rendering.
+# ---------------------------------------------------------------------------
+def esc(s):
+    return str(s).replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+
+def _li(items, cls=""):
+    if not items:
+        return "<span class='muted'>none</span>"
+    c = f" class='{cls}'" if cls else ""
+    return f"<ul{c}>" + "".join(f"<li>{esc(x)}</li>" for x in items) + "</ul>"
+
+
+def record_html(name):
+    cl = get_client(name) if name else None
+    if not cl:
+        return "<div class='muted'>Pick a client, or type an update in the command bar.</div>"
+    r = cl["record"]
+    last = cl["last_contacted"] or "never"
+    dsl = _days_since(cl["last_contacted"])
+    last_txt = f"{last}" + (f" ({dsl}d ago)" if dsl is not None else "")
+    stage = r.get("stage") or "Unsorted"
+    tl = "".join(
+        f"<div class='tl-row'><span class='tl-date'>{esc(e.get('date',''))}</span>"
+        f"<span class='tl-event'>{esc(e.get('event',''))}</span></div>"
+        for e in reversed(cl["timeline"])
+    ) or "<span class='muted'>no events yet</span>"
+    return f"""
+    <div class="record">
+      <div class="rec-head">
+        <span class="rec-name">{esc(cl['name'])}</span>
+        <span class="stage-badge">{esc(stage)}</span>
+      </div>
+      <div class="rec-dates">Customer since {esc(cl['customer_since'] or '?')} &middot; last contact {esc(last_txt)}</div>
+      <div class="rec-row"><span class="rec-label">Goals</span><span class="rec-val">{esc(r.get('goals','')) or '<span class=muted>not set</span>'}</span></div>
+      <div class="rec-row"><span class="rec-label">Protocol</span><span class="rec-val">{esc(r.get('current_protocol','')) or '<span class=muted>not set</span>'}</span></div>
+      <div class="rec-row"><span class="rec-label">Next step</span><span class="rec-val next">{esc(r.get('next_step','')) or '<span class=muted>not set</span>'}</span></div>
+      <div class="rec-block"><div class="rec-label">Watch for</div>{_li(r.get('flags',[]), 'flags')}</div>
+      <div class="rec-block"><div class="rec-label">Open follow-ups</div>{_li(r.get('follow_ups',[]), 'follow')}</div>
+      <div class="rec-block"><div class="rec-label">Timeline</div><div class="timeline">{tl}</div></div>
+    </div>"""
+
+
+def board_html():
+    clients = all_clients()
+    cols = []
+    for stage in STAGES:
+        chips = "".join(
+            f"<div class='chip'>{esc(c['name'])}</div>"
+            for c in clients if c["record"].get("stage") == stage
+        )
+        cols.append(f"<div class='col'><div class='col-head'>{esc(stage)}</div>{chips or '<div class=muted>-</div>'}</div>")
+    unsorted = [c for c in clients if c["record"].get("stage") not in STAGES]
+    if unsorted:
+        chips = "".join(f"<div class='chip'>{esc(c['name'])}</div>" for c in unsorted)
+        cols.append(f"<div class='col'><div class='col-head'>Unsorted</div>{chips}</div>")
+    return f"<div class='board'>{''.join(cols)}</div>"
+
+
+def needs_html():
+    rows = []
+    for c in all_clients():
+        reasons = []
+        dsl = _days_since(c["last_contacted"])
+        if dsl is None:
+            reasons.append("never contacted")
+        elif dsl >= STALE_DAYS:
+            reasons.append(f"no contact in {dsl}d")
+        for f in c["record"].get("follow_ups", []):
+            reasons.append(f"follow-up: {f}")
+        if reasons:
+            rows.append(
+                f"<div class='need'><span class='need-name'>{esc(c['name'])}</span>"
+                f"<span class='need-why'>{esc('; '.join(reasons))}</span></div>"
             )
-            frames_in = gr.State(
-                []
-            )  # replace with a gr.File / example picker wired to your loader
-            run_btn = gr.Button("Judge episode", variant="primary")
-        with gr.Column():
-            plot_out = gr.Plot(label="Progress curve")
-            summary_out = gr.Textbox(label="Result")
-            voc_out = gr.Number(label="VOC")
-    run_btn.click(run, [frames_in, task_in], [plot_out, summary_out, voc_out])
+    if not rows:
+        return "<div class='muted'>Nothing needs attention. Nice.</div>"
+    return "".join(rows)
+
+
+def kb_html():
+    entries = list_kb()
+    if not entries:
+        return "<div class='muted'>Empty. Methods you state in updates get suggested here, or seed one below.</div>"
+    return "<div class='kb-wrap'>" + "".join(
+        f"<div class='kb-card'><div class='kb-title'>{esc(e['title'])}</div>"
+        f"<div class='kb-body'>{esc(e['body'])}</div></div>" for e in entries
+    ) + "</div>"
+
+
+# ---------------------------------------------------------------------------
+# Actions.
+# ---------------------------------------------------------------------------
+def _refresh(active):
+    return record_html(active), board_html(), needs_html()
+
+
+def on_command(text, active):
+    """The single command bar. Routes to update or query."""
+    text = (text or "").strip()
+    if not text:
+        out = "Type an update or a question."
+        return (out, record_html(active), board_html(), needs_html(),
+                gr.update(), gr.update(choices=[], value=[]), [], "")
+
+    route = _post(EXTRACT_URL, {"op": "route", "text": text, "clients": list_clients()})
+    intent = route.get("intent", "update")
+    if text.endswith("?"):
+        intent = "query"  # safety net: questions end with a question mark
+
+    if intent == "query":
+        who = route.get("client", "")
+        cl = get_client(who) if who else None
+        if cl:
+            context = json.dumps(
+                {"client": cl["name"], "customer_since": cl["customer_since"],
+                 "last_contacted": cl["last_contacted"], "record": cl["record"],
+                 "timeline": cl["timeline"]}, ensure_ascii=False)
+        else:
+            roster = [
+                {"name": c["name"], "stage": c["record"].get("stage", ""),
+                 "last_contacted": c["last_contacted"], "next_step": c["record"].get("next_step", ""),
+                 "follow_ups": c["record"].get("follow_ups", [])}
+                for c in all_clients()
+            ]
+            context = json.dumps({"clients": roster}, ensure_ascii=False)
+        answer = _strip_think(_post(COACH_URL, {"op": "answer", "context": context, "question": text})["answer"])
+        out = f"**Q:** {esc(text)}\n\n{answer}"
+        return (out, record_html(active), board_html(), needs_html(),
+                gr.update(), gr.update(choices=[], value=[]), [], "")
+
+    # Update path.
+    name = ensure_client(route.get("client", ""))
+    existing = get_client(name)["record"]
+    res = _post(EXTRACT_URL, {"op": "extract", "existing": existing, "new_text": text})
+    record, event = res["record"], res.get("event", "")
+    save_update(name, record, event)
+    methods = _post(EXTRACT_URL, {"op": "harvest", "new_text": text})["methods"]
+    titles = [m["title"] for m in methods]
+    stage = record.get("stage") or "Unsorted"
+    out = (f"Filed under **{esc(name)}** ({esc(stage)})."
+           + (f" Logged: _{esc(event)}_" if event else "")
+           + (f"\n\nFound {len(methods)} reusable method(s) to save on the right." if methods else ""))
+    return (out, record_html(name), board_html(), needs_html(),
+            gr.update(choices=list_clients(), value=name),
+            gr.update(choices=titles, value=titles), methods, "")
+
+
+def on_select_client(name):
+    return record_html(name)
+
+
+def on_save_methods(selected, candidates):
+    by_title = {m["title"]: m for m in (candidates or [])}
+    added = 0
+    for t in selected or []:
+        m = by_title.get(t)
+        if m:
+            add_kb(m["title"], m["body"])
+            added += 1
+    return kb_html(), gr.update(choices=[], value=[]), [], f"Saved {added} method(s)."
+
+
+def on_seed_kb(title, body):
+    add_kb(title, body)
+    return kb_html(), "", "", "Added to knowledgebase."
+
+
+def on_brief(name, question):
+    if not name:
+        return "Pick a client first."
+    record = get_client(name)["record"]
+    kb = retrieve_kb(record)
+    out = _strip_think(_post(COACH_URL, {"op": "brief", "record": record, "kb": kb, "question": question})["brief"])
+    used = ", ".join(e["title"] for e in kb) if kb else "none yet"
+    return f"**Knowledgebase used:** {used}\n\n{out}"
+
+
+# ---------------------------------------------------------------------------
+# UI.
+# ---------------------------------------------------------------------------
+CSS = """
+:root { --bg:#0c0f14; --panel:#151a23; --panel2:#1b212c; --ink:#eef2f8;
+        --muted:#7e8aa0; --accent:#46d6a6; --accent2:#5b8cff; --line:#26303f; --warn:#f0a35e; }
+.gradio-container { background:
+  radial-gradient(1100px 500px at 80% -10%, #16241f 0%, transparent 60%), var(--bg) !important;
+  color: var(--ink) !important; font-family:'Inter', system-ui, sans-serif; }
+#brand { font-size:1.7rem; font-weight:800; letter-spacing:-.02em;
+  background:linear-gradient(90deg,#7fe9c6,#8fb0ff); -webkit-background-clip:text; -webkit-text-fill-color:transparent; }
+#tag { color:var(--muted); margin-top:-.35rem; font-size:.9rem; }
+.muted { color:var(--muted); }
+#cmdout { background:var(--panel); border:1px solid var(--line); border-radius:12px; padding:6px 14px; min-height:2.2rem; }
+.record { background:var(--panel); border:1px solid var(--line); border-radius:14px; padding:16px 18px; }
+.rec-head { display:flex; align-items:center; gap:10px; }
+.rec-name { font-weight:800; font-size:1.15rem; }
+.stage-badge { background:linear-gradient(90deg,#2f6b58,#33507f); color:#dffaf0; font-size:.72rem;
+  padding:3px 9px; border-radius:999px; letter-spacing:.04em; }
+.rec-dates { color:var(--muted); font-size:.8rem; margin:4px 0 10px; }
+.rec-row { display:flex; gap:10px; margin:4px 0; }
+.rec-label { color:var(--accent); font-size:.74rem; text-transform:uppercase; letter-spacing:.06em; min-width:84px; padding-top:2px; }
+.rec-val.next { color:#bfe0ff; font-weight:600; }
+.rec-block { margin-top:10px; }
+.rec-block ul { margin:4px 0 0; padding-left:18px; }
+.rec-block li { margin:3px 0; color:#d4dbe8; font-size:.93rem; }
+ul.flags li { color:var(--warn); } ul.follow li { color:#9fd0ff; }
+.timeline { margin-top:4px; }
+.tl-row { display:flex; gap:10px; font-size:.86rem; margin:2px 0; }
+.tl-date { color:var(--muted); min-width:78px; } .tl-event { color:#cfd6e6; }
+.board { display:flex; gap:8px; overflow-x:auto; padding-bottom:4px; }
+.col { background:var(--panel); border:1px solid var(--line); border-radius:10px; padding:8px; min-width:120px; flex:1; }
+.col-head { color:var(--accent); font-size:.7rem; text-transform:uppercase; letter-spacing:.05em; margin-bottom:6px; }
+.chip { background:var(--panel2); border:1px solid var(--line); border-radius:8px; padding:5px 8px; margin:4px 0; font-size:.82rem; }
+.need { display:flex; flex-direction:column; background:var(--panel2); border-left:3px solid var(--warn);
+  border-radius:8px; padding:7px 10px; margin:6px 0; }
+.need-name { font-weight:700; font-size:.9rem; } .need-why { color:var(--warn); font-size:.8rem; }
+.kb-wrap { display:flex; flex-direction:column; gap:8px; max-height:240px; overflow:auto; }
+.kb-card { background:var(--panel2); border:1px solid var(--line); border-radius:10px; padding:9px 11px; }
+.kb-title { font-weight:700; color:#bfe9d8; font-size:.9rem; } .kb-body { color:#c3cad8; font-size:.84rem; }
+.gr-button-primary { background:linear-gradient(90deg,#3fcfa0,#4f84ff) !important; border:none !important; }
+"""
+
+db_init()
+_initial = (list_clients() or [None])[0]
+
+with gr.Blocks(title="Spruce") as demo:
+    gr.HTML(
+        "<div id='brand'>🌲 Spruce</div>"
+        "<div id='tag'>The CRM you talk to. Type what happened and it files itself; "
+        "ask a question and it answers. MiniCPM3-4B writes, Nemotron-3-Nano-4B reads. Both on Modal.</div>"
+    )
+
+    candidates_state = gr.State([])
+
+    with gr.Row():
+        cmd = gr.Textbox(
+            label="",
+            placeholder="e.g. Had a call with Max, booked his analysis call Thursday, wants to drop 5kg  |  or:  what's the update on Dana?",
+            lines=2, scale=5,
+        )
+        send = gr.Button("Send", variant="primary", scale=1)
+    cmd_out = gr.Markdown(elem_id="cmdout")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown("### Client")
+            client = gr.Dropdown(choices=list_clients(), value=_initial, label="Active client", interactive=True)
+            record_view = gr.HTML(record_html(_initial))
+        with gr.Column(scale=2):
+            gr.Markdown("### Needs attention")
+            needs_view = gr.HTML(needs_html())
+            with gr.Accordion("Knowledgebase", open=False):
+                kb_view = gr.HTML(kb_html())
+                cand_pick = gr.CheckboxGroup(choices=[], label="Methods found in last update")
+                save_methods_btn = gr.Button("Save selected")
+                kb_title = gr.Textbox(label="Seed a method: title")
+                kb_body = gr.Textbox(label="Body", lines=2)
+                seed_btn = gr.Button("Add to knowledgebase")
+            with gr.Accordion("Brief me from my knowledgebase", open=False):
+                brief_q = gr.Textbox(label="Before I reply, what should I consider?", lines=1)
+                brief_btn = gr.Button("Brief me")
+                brief_out = gr.Markdown()
+
+    gr.Markdown("### Pipeline board")
+    board_view = gr.HTML(board_html())
+
+    # Wiring.
+    send.click(
+        on_command, [cmd, client],
+        [cmd_out, record_view, board_view, needs_view, client, cand_pick, candidates_state, cmd],
+    )
+    cmd.submit(
+        on_command, [cmd, client],
+        [cmd_out, record_view, board_view, needs_view, client, cand_pick, candidates_state, cmd],
+    )
+    client.change(on_select_client, client, record_view)
+    save_methods_btn.click(on_save_methods, [cand_pick, candidates_state], [kb_view, cand_pick, candidates_state, cmd_out])
+    seed_btn.click(on_seed_kb, [kb_title, kb_body], [kb_view, kb_title, kb_body, cmd_out])
+    brief_btn.click(on_brief, [client, brief_q], brief_out)
+
 
 if __name__ == "__main__":
-    demo.launch()
+    # Gradio 6 moved css/theme from the Blocks constructor to launch().
+    demo.launch(css=CSS, theme=gr.themes.Base())

modal_app.py

@@ -0,0 +1,437 @@
+"""
+Spruce backend on Modal: the model layer for an AI-native CRM a health coach
+talks to instead of maintaining a Kanban board by hand.
+
+Two genuinely small (<=4B) models, each doing the job it is good at:
+
+  * openbmb/MiniCPM3-4B  -> the write path. It reads a raw natural-language
+    update ("had a call with Max, booked his analysis call, he wants to drop
+    5kg") and does three jobs: ROUTE it to the right client (or flag a new one),
+    EXTRACT a structured record and a one-line timeline event, classify the
+    pipeline STAGE, and HARVEST any reusable method the coach states.
+
+  * nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16 -> the read/reason path. It ANSWERS
+    natural-language questions over the client data ("what's the update on Max?",
+    "who have I not contacted in a while?") and writes a grounded coaching BRIEF
+    from the coach's own knowledgebase. It never messages a client and never
+    introduces outside clinical claims.
+
+Neither model does medicine. One turns language into structured records, the
+other reasons over data the coach supplied. That keeps the small-model fit
+honest.
+
+The two need different runtimes (MiniCPM3 pins transformers 4.41; Nemotron's
+hybrid Mamba needs vLLM's kernels), so they run as two separate Modal services
+with their own images, each warm-loaded and scaling to zero.
+
+Prize alignment (build-small-hackathon): Modal (both run here), OpenBMB
+(MiniCPM3-4B), NVIDIA (Nemotron), Tiny Titan (both <=4B), Best Agent (route ->
+update -> classify -> remind is agentic), Off-Brand (custom CRM UI).
+
+Usage:
+  modal deploy modal_app.py     # prints the two web endpoint URLs for the Space
+"""
+
+import json
+import re
+
+import modal
+
+MINUTES = 60
+
+EXTRACT_MODEL = "openbmb/MiniCPM3-4B"
+COACH_MODEL = "nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16"
+
+# Elijah's client journey. The model classifies each update into one of these.
+STAGES = [
+    "Discovery Call",
+    "Customer booked",
+    "Analysis call",
+    "Second call",
+    "Weeks 1-4",
+    "Weeks 5-8",
+]
+
+# Model-maintained fields of a client record. Dates and timeline are kept by the
+# cockpit, not the model (the model has no reliable clock).
+EMPTY_RECORD = {
+    "stage": "",
+    "goals": "",
+    "current_protocol": "",
+    "next_step": "",
+    "flags": [],
+    "follow_ups": [],
+}
+
+# MiniCPM3 remote code targets transformers 4.41; 5.x breaks it.
+extract_image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .pip_install(
+        "torch",
+        "transformers==4.41.2",
+        "accelerate",
+        "sentencepiece",
+        "numpy",
+        "fastapi[standard]",
+    )
+    .env({"HF_HOME": "/cache"})
+)
+
+# Nemotron-3-Nano is a hybrid Mamba/Transformer. vLLM ships NemotronH support and
+# the Mamba kernels, which plain transformers does not build cleanly.
+# VLLM_USE_FLASHINFER_SAMPLER=0: we decode greedily (temperature 0), so we do not
+# need FlashInfer's sampler, which would otherwise JIT-compile a CUDA kernel at
+# startup and fail because the slim image has no nvcc.
+coach_image = (
+    modal.Image.debian_slim(python_version="3.12")
+    .pip_install("vllm", "fastapi[standard]")
+    # Remove flashinfer so vLLM uses its native PyTorch sampler. flashinfer would
+    # otherwise JIT-compile a CUDA kernel at startup and crash (no nvcc in slim).
+    .run_commands("python -m pip uninstall -y flashinfer-python flashinfer || true")
+    .env({"HF_HOME": "/cache", "VLLM_USE_FLASHINFER_SAMPLER": "0"})
+)
+
+app = modal.App("coach-cockpit")
+hf_cache = modal.Volume.from_name("coach-cockpit-cache", create_if_missing=True)
+
+
+# ---------------------------------------------------------------------------
+# Service 1: MiniCPM3-4B. Route, extract, classify, harvest.
+# ---------------------------------------------------------------------------
+@app.cls(
+    gpu="L4",
+    image=extract_image,
+    volumes={"/cache": hf_cache},
+    timeout=20 * MINUTES,
+    scaledown_window=300,
+)
+class Extractor:
+    @modal.enter()
+    def load(self):
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+
+        self.torch = torch
+        self.tok = AutoTokenizer.from_pretrained(EXTRACT_MODEL, trust_remote_code=True)
+        if self.tok.pad_token is None:
+            self.tok.pad_token = self.tok.eos_token
+        self.tok.padding_side = "left"
+        self.model = AutoModelForCausalLM.from_pretrained(
+            EXTRACT_MODEL,
+            trust_remote_code=True,
+            torch_dtype=torch.bfloat16,
+            device_map="cuda",
+        ).eval()
+
+    def _generate(self, messages, max_new_tokens=512):
+        prompt = self.tok.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=True
+        )
+        inputs = self.tok(prompt, return_tensors="pt").to("cuda")
+        with self.torch.no_grad():
+            out = self.model.generate(
+                **inputs,
+                max_new_tokens=max_new_tokens,
+                do_sample=False,
+                pad_token_id=self.tok.pad_token_id,
+            )
+        gen = out[:, inputs["input_ids"].shape[1]:]
+        return self.tok.decode(gen[0], skip_special_tokens=True).strip()
+
+    def _route_impl(self, text, clients):
+        """Decide if this is an update or a question, and which client it is about."""
+        roster = ", ".join(clients) if clients else "(no clients yet)"
+        sys = (
+            "You triage a health coach's inbox. Given a list of existing clients "
+            "and one thing the coach typed, decide:\n"
+            '  intent: "update" if the coach is reporting something that happened '
+            'or a plan, "query" if the coach is asking a question.\n'
+            "  client: the existing client this is about, matched from the list "
+            "(match partial names, e.g. 'Max' -> 'Max Mustermann'). Empty string "
+            "if it is a general question about no single client.\n"
+            "  is_new: true only if intent is update and the named person is not "
+            "in the list.\n"
+            "Return ONLY a JSON object: "
+            '{"intent": "...", "client": "...", "is_new": true/false}.'
+        )
+        user = f"Existing clients: {roster}\n\nCoach typed: {text}"
+        out = self._generate(
+            [{"role": "system", "content": sys}, {"role": "user", "content": user}],
+            max_new_tokens=120,
+        )
+        obj = _extract_json(out) or {}
+        intent = obj.get("intent", "update")
+        if intent not in ("update", "query"):
+            intent = "update"
+        return {
+            "intent": intent,
+            "client": str(obj.get("client", "") or ""),
+            "is_new": bool(obj.get("is_new", False)),
+        }
+
+    def _extract_impl(self, existing, new_text):
+        """Merge an update into the record, classify the stage, summarize the event."""
+        existing = {**EMPTY_RECORD, **(existing or {})}
+        sys = (
+            "You maintain a health coach's private record on one client. You are "
+            "given the CURRENT record as JSON and a NEW update the coach typed. "
+            "Update the record using only information present in the text. Never "
+            "invent facts. Keep entries short.\n"
+            f"Classify the client's current stage as exactly one of: {STAGES}. "
+            "If the update does not change the stage, keep the current one.\n"
+            "Also write 'event': one short past-tense line summarizing what "
+            "happened in this update, for a timeline.\n"
+            "Return ONLY a JSON object with these keys:\n"
+            f'  "stage": one of {STAGES} or "",\n'
+            '  "goals": string,\n'
+            '  "current_protocol": string,\n'
+            '  "next_step": string (the single next action),\n'
+            '  "flags": array of short strings (things to watch),\n'
+            '  "follow_ups": array of short strings (open promises),\n'
+            '  "event": string (one line, past tense).'
+        )
+        user = (
+            f"CURRENT record:\n{json.dumps(existing, ensure_ascii=False)}\n\n"
+            f"NEW update:\n{new_text}"
+        )
+        out = self._generate(
+            [{"role": "system", "content": sys}, {"role": "user", "content": user}]
+        )
+        obj = _extract_json(out)
+        record = _coerce_record(obj, existing)
+        event = ""
+        if isinstance(obj, dict):
+            event = str(obj.get("event", "") or "").strip()
+        return {"record": record, "event": event}
+
+    def _harvest_impl(self, new_text):
+        """Pull reusable methods the coach states, to grow the knowledgebase."""
+        sys = (
+            "You read something a health coach wrote. Extract any general method, "
+            "protocol, or recommendation that could be reused with other clients. "
+            "Ignore client-specific logistics and chit-chat. Return ONLY a JSON "
+            'array of objects, each with "title" (a few words) and "body" (one or '
+            "two sentences). If nothing is reusable, return []."
+        )
+        out = self._generate(
+            [{"role": "system", "content": sys}, {"role": "user", "content": new_text}],
+            max_new_tokens=400,
+        )
+        items = _extract_json(out)
+        if not isinstance(items, list):
+            return []
+        clean = []
+        for it in items:
+            if isinstance(it, dict) and it.get("title") and it.get("body"):
+                clean.append({"title": str(it["title"]), "body": str(it["body"])})
+        return clean
+
+    @modal.method()
+    def route(self, text, clients):
+        return self._route_impl(text, clients)
+
+    @modal.method()
+    def extract(self, existing, new_text):
+        return self._extract_impl(existing, new_text)
+
+    @modal.method()
+    def harvest(self, new_text):
+        return self._harvest_impl(new_text)
+
+    @modal.fastapi_endpoint(method="POST")
+    def web(self, payload: dict):
+        """POST one of:
+        {"op":"route","text":"...","clients":[...]}
+        {"op":"extract","existing":{...},"new_text":"..."}
+        {"op":"harvest","new_text":"..."}"""
+        op = payload.get("op", "extract")
+        if op == "route":
+            return self._route_impl(payload.get("text", ""), payload.get("clients", []))
+        if op == "harvest":
+            return {"methods": self._harvest_impl(payload.get("new_text", ""))}
+        return self._extract_impl(payload.get("existing"), payload.get("new_text", ""))
+
+
+# ---------------------------------------------------------------------------
+# Service 2: Nemotron-3-Nano-4B on vLLM. Answer questions, write briefs.
+# ---------------------------------------------------------------------------
+@app.cls(
+    gpu="L4",
+    image=coach_image,
+    volumes={"/cache": hf_cache},
+    timeout=20 * MINUTES,
+    scaledown_window=300,
+)
+class Coach:
+    @modal.enter()
+    def load(self):
+        from vllm import LLM, SamplingParams
+
+        self.SamplingParams = SamplingParams
+        self.llm = LLM(
+            model=COACH_MODEL,
+            trust_remote_code=True,
+            dtype="bfloat16",
+            max_model_len=8192,
+            gpu_memory_utilization=0.92,
+            enforce_eager=True,  # skip CUDA graph capture for a faster cold start
+        )
+
+    def _generate(self, messages, max_new_tokens=700):
+        # Nemotron-3-Nano is a reasoning model: it emits <think>...</think> before
+        # the answer. Give it room to think, then keep only the post-think answer.
+        params = self.SamplingParams(temperature=0.0, max_tokens=max_new_tokens)
+        outs = self.llm.chat(messages, params, use_tqdm=False)
+        text = outs[0].outputs[0].text.strip()
+        if "</think>" in text:
+            text = text.split("</think>")[-1].strip()
+        return text
+
+    def _answer_impl(self, context, question):
+        """Answer a natural-language question over the CRM data given as context."""
+        sys = (
+            "You are the assistant inside a health coach's CRM. Answer the coach's "
+            "question using ONLY the data below. Be concise and direct. If the data "
+            "does not contain the answer, say so plainly. Do not invent clients, "
+            "dates, or facts."
+        )
+        user = f"CRM DATA:\n{context}\n\nQUESTION: {question}"
+        return self._generate(
+            [{"role": "system", "content": sys}, {"role": "user", "content": user}]
+        )
+
+    def _brief_impl(self, record, kb, question):
+        """A grounded brief from the coach's own knowledgebase before they reply."""
+        kb_text = (
+            "\n".join(f"- {e.get('title','')}: {e.get('body','')}" for e in kb)
+            if kb
+            else "(no matching knowledgebase entries)"
+        )
+        sys = (
+            "You brief a health coach before they reply to a client. You are not "
+            "the coach and you do not message the client. Use ONLY the client "
+            "record and the coach's own knowledgebase below. Do not introduce "
+            "outside medical claims. Write short bullet sections:\n"
+            "  RELEVANT METHODS: which knowledgebase entries apply and why (name them).\n"
+            "  ALREADY NOTED: what the record already shows.\n"
+            "  WATCH FOR: flags to respect.\n"
+            "  TALKING POINTS: a few angles the coach could raise.\n"
+            "End with: 'Not medical advice. Coach reviews before sending.'"
+        )
+        user = (
+            f"CLIENT RECORD:\n{json.dumps(record or EMPTY_RECORD, ensure_ascii=False)}"
+            f"\n\nKNOWLEDGEBASE:\n{kb_text}"
+            f"\n\nCOACH'S QUESTION: {question or 'What should I consider before replying?'}"
+        )
+        return self._generate(
+            [{"role": "system", "content": sys}, {"role": "user", "content": user}]
+        )
+
+    @modal.method()
+    def answer(self, context, question):
+        return self._answer_impl(context, question)
+
+    @modal.method()
+    def brief(self, record, kb, question=""):
+        return self._brief_impl(record, kb, question)
+
+    @modal.fastapi_endpoint(method="POST")
+    def web(self, payload: dict):
+        """POST one of:
+        {"op":"answer","context":"...","question":"..."}
+        {"op":"brief","record":{...},"kb":[{title,body}],"question":"..."}"""
+        op = payload.get("op", "answer")
+        if op == "brief":
+            return {
+                "brief": self._brief_impl(
+                    payload.get("record"), payload.get("kb", []), payload.get("question", "")
+                )
+            }
+        return {
+            "answer": self._answer_impl(
+                payload.get("context", ""), payload.get("question", "")
+            )
+        }
+
+
+# ---------------------------------------------------------------------------
+# Parsing helpers.
+# ---------------------------------------------------------------------------
+def _extract_json(text):
+    """Pull the first JSON object or array out of model output, defensively."""
+    if not text:
+        return None
+    text = re.sub(r"```(?:json)?", "", text)
+    start = None
+    for i, ch in enumerate(text):
+        if ch in "{[":
+            start = i
+            break
+    if start is None:
+        return None
+    opener = text[start]
+    closer = "}" if opener == "{" else "]"
+    depth = 0
+    for j in range(start, len(text)):
+        if text[j] == opener:
+            depth += 1
+        elif text[j] == closer:
+            depth -= 1
+            if depth == 0:
+                try:
+                    return json.loads(text[start : j + 1])
+                except json.JSONDecodeError:
+                    return None
+    return None
+
+
+def _coerce_record(obj, existing):
+    """Force whatever the model returned into the record shape. Never raises."""
+    existing = {**EMPTY_RECORD, **(existing or {})}
+    if not isinstance(obj, dict):
+        return {k: existing[k] for k in EMPTY_RECORD}
+    out = {}
+    stage = str(obj.get("stage", existing.get("stage", "")) or "")
+    out["stage"] = stage if stage in STAGES else existing.get("stage", "")
+    for key in ("goals", "current_protocol", "next_step"):
+        out[key] = str(obj.get(key, existing.get(key, "")) or "")
+    for key in ("flags", "follow_ups"):
+        val = obj.get(key, existing.get(key, []))
+        if isinstance(val, str):
+            val = [val] if val else []
+        elif not isinstance(val, list):
+            val = list(existing.get(key, []))
+        out[key] = [str(x) for x in val if str(x).strip()]
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Synthetic smoke test. Run with: modal run --detach modal_app.py
+# (detach keeps the app alive through the slow vLLM cold start).
+# ---------------------------------------------------------------------------
+_SAMPLE_UPDATE = (
+    "Had my discovery call with Max Mustermann today. He wants to drop 5kg before "
+    "September and fix his afternoon energy crashes. Booked his analysis call for "
+    "Thursday and told him to start a food log. As a rule I have clients front-load "
+    "protein at breakfast when they report afternoon dips."
+)
+
+
+@app.local_entrypoint()
+def main():
+    ext = Extractor()
+    coach = Coach()
+
+    print("=== route: who is this about, update or question? ===")
+    print(ext.route.remote(_SAMPLE_UPDATE, ["Dana R.", "Sam P."]))
+
+    print("\n=== extract: structured record + stage + timeline event ===")
+    res = ext.extract.remote(EMPTY_RECORD, _SAMPLE_UPDATE)
+    print(json.dumps(res, indent=2, ensure_ascii=False))
+
+    print("\n=== harvest: reusable methods for the knowledgebase ===")
+    print(json.dumps(ext.harvest.remote(_SAMPLE_UPDATE), indent=2, ensure_ascii=False))
+
+    print("\n=== answer: concierge Q&A over the record ===")
+    ctx = json.dumps({"Max Mustermann": res["record"]}, ensure_ascii=False)
+    print(coach.answer.remote(ctx, "What is the next step for Max?"))

requirements.txt

@@ -1,14 +1,5 @@
-# ZeroGPU images already include CUDA torch/torchvision, so do not pin them here.
-# Match the transformers pin (and any extras like timm) to the MiniCPM-V model card
-# at https://huggingface.co/openbmb/MiniCPM-V-4_5 to avoid trust_remote_code load errors.
-
+# Spruce is a thin cockpit. Both models (MiniCPM3-4B and Nemotron-3-Nano-4B)
+# run on Modal, so no torch / transformers / vllm here. The cockpit stores
+# state in SQLite (stdlib) and reaches the models over HTTP with requests.
 gradio
-spaces
-transformers
-accelerate
-sentencepiece
-pillow
-scipy
-numpy
-matplotlib
-decord
+requests