Spaces:

zkmine
/

dialectica

Sleeping

App Files Files Community

Kattine commited on Jun 27

Commit

7ff3e94

1 Parent(s): 3877b20

Phase 8: provider toggle, layout fix, markdown rendering

Browse files

Files changed (10) hide show

.dockerignore +14 -0
Dockerfile +37 -0
config.py +26 -0
frontend/index.html +514 -0
main.py +171 -7
requirements-app.txt +24 -0
requirements.txt +7 -5
scripts/expert.py +164 -0
scripts/inference.py +95 -0
scripts/parsing.py +63 -0

.dockerignore ADDED Viewed

	@@ -0,0 +1,14 @@

+# Keep the image small: exclude local artifacts that are not needed at runtime.
+venv/
+.venv/
+__pycache__/
+*.pyc
+.git/
+.env
+data/raw/
+data/processed/
+data/outputs/
+models/
+notebooks/
+*.zip
+.DS_Store

Dockerfile ADDED Viewed

	@@ -0,0 +1,37 @@

+# Dockerfile for deploying Dialectica on Hugging Face Spaces (Docker SDK).
+#
+# Notes specific to Spaces:
+#   * The app must listen on port 7860.
+#   * Only /tmp is writable, so all model caches are redirected there.
+#   * The fine-tuned DistilBERT is pulled from the Hugging Face Hub at startup
+#     (set MODEL_REPO below), so it does not need to be baked into the image.
+FROM python:3.11-slim
+# System deps for PyMuPDF and general builds.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+# Redirect all model/library caches to /tmp (the only writable dir on Spaces).
+ENV HF_HOME=/tmp/hf_home \
+    TRANSFORMERS_CACHE=/tmp/hf_home \
+    SENTENCE_TRANSFORMERS_HOME=/tmp/st_home \
+    XDG_CACHE_HOME=/tmp/cache \
+    MPLCONFIGDIR=/tmp/mpl
+WORKDIR /app
+# Install Python dependencies first for better layer caching.
+# Install the CPU build of torch explicitly to avoid pulling large CUDA wheels.
+COPY requirements-app.txt .
+RUN pip install --no-cache-dir "torch>=2.2.0" --index-url https://download.pytorch.org/whl/cpu
+RUN pip install --no-cache-dir --upgrade -r requirements-app.txt
+# Copy the application code.
+COPY . .
+# Spaces expects the app on port 7860.
+EXPOSE 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

config.py CHANGED Viewed

@@ -291,3 +291,29 @@ class DeepModelConfig:
     # for a speedup if your macOS supports it.
     use_bf16: bool = False
     seed: int = 42

     # for a speedup if your macOS supports it.
     use_bf16: bool = False
     seed: int = 42
+# Product layer (Dialectica app) parameters
+@dataclass
+class ProductConfig:
+    """Configuration for the Dialectica application backend."""
+    # the fine-tuned classifier saved by Phase 4b
+    classifier_dir: str = "models/distilbert_bloom"
+    # sentence embedding model for matching a question to a concept
+    embed_model: str = "all-MiniLM-L6-v2"
+    # expert dialogue provider: "deepseek" (default, no rate limits) or "gemini"
+    provider: str = "deepseek"
+    deepseek_model: str = "deepseek-v4-flash"
+    gemini_model: str = "gemini-2.5-flash"
+    # how much material text to inject as the expert's knowledge context
+    max_context_chars: int = 12000
+    # number of key concepts to extract from uploaded material
+    num_concepts: int = 10
+    # minimum cosine similarity to attribute a question to a concept
+    concept_match_threshold: float = 0.25
+    max_question_length: int = 64

frontend/index.html ADDED Viewed

	@@ -0,0 +1,514 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Dialectica — interrogate the expert</title>
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;1,6..72,400&family=Inter:wght@400;500;600&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
+<script src="https://cdn.jsdelivr.net/npm/marked@12.0.0/marked.min.js"></script>
+<style>
+  :root {
+    --desk: #1B1D23;
+    --paper: #EDEAE2;
+    --paper-inset: #E3DFD5;
+    --ink: #22262E;
+    --ink-soft: #61656d;
+    --rule: rgba(34,38,46,.14);
+    --rule-strong: rgba(34,38,46,.28);
+    --surface: #9FB8C6;
+    --mech: #3F6E96;
+    --crit: #B14A2F;
+    --crit-ink: #8d3a23;
+    --paper-shadow: 0 1px 0 rgba(255,255,255,.5) inset, 0 18px 40px rgba(0,0,0,.32);
+  }
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  html, body { height: 100%; }
+  body {
+    background: var(--desk);
+    color: var(--ink);
+    font-family: 'Inter', sans-serif;
+    font-size: 15px;
+    line-height: 1.5;
+    -webkit-font-smoothing: antialiased;
+  }
+  .mono { font-family: 'IBM Plex Mono', monospace; }
+  /* ---- header ---- */
+  header {
+    display: flex; align-items: baseline; justify-content: space-between;
+    padding: 22px 32px 18px; color: var(--paper);
+    border-bottom: 1px solid rgba(237,234,226,.12);
+  }
+  .wordmark {
+    font-family: 'Newsreader', serif; font-weight: 500; font-size: 30px;
+    letter-spacing: .01em;
+  }
+  .wordmark .dot { color: var(--crit); }
+  .tagline {
+    font-family: 'IBM Plex Mono', monospace; font-size: 11px;
+    text-transform: uppercase; letter-spacing: .22em; color: rgba(237,234,226,.55);
+  }
+  .reset {
+    font-family: 'IBM Plex Mono', monospace; font-size: 11px;
+    text-transform: uppercase; letter-spacing: .14em;
+    color: rgba(237,234,226,.7); background: none; border: 1px solid rgba(237,234,226,.25);
+    padding: 7px 13px; border-radius: 2px; cursor: pointer; transition: .15s;
+  }
+  .reset:hover { color: var(--paper); border-color: rgba(237,234,226,.5); }
+  /* provider toggle */
+  .provider-pick {
+    display: flex; align-items: center; gap: 8px;
+  }
+  .provider-pick label {
+    font-family: 'IBM Plex Mono', monospace; font-size: 10px;
+    text-transform: uppercase; letter-spacing: .16em; color: rgba(237,234,226,.5);
+  }
+  .seg-toggle { display: flex; border: 1px solid rgba(237,234,226,.25); border-radius: 2px; overflow: hidden; }
+  .seg-toggle button {
+    font-family: 'IBM Plex Mono', monospace; font-size: 11px; letter-spacing: .08em;
+    background: none; border: none; color: rgba(237,234,226,.6);
+    padding: 6px 12px; cursor: pointer; transition: .15s;
+  }
+  .seg-toggle button.active { background: var(--crit); color: #fff; }
+  .seg-toggle button:not(.active):hover { color: var(--paper); }
+  /* ---- workspace ---- */
+  .workspace {
+    display: grid; grid-template-columns: minmax(300px, 38%) 1fr;
+    gap: 22px; padding: 22px 32px 32px; height: calc(100vh - 73px);
+  }
+  .panel {
+    background: var(--paper); border-radius: 3px; box-shadow: var(--paper-shadow);
+    display: flex; flex-direction: column; overflow: hidden; position: relative;
+  }
+  .panel::before {
+    content: ""; position: absolute; inset: 0; pointer-events: none;
+    border-radius: 3px; border: 1px solid rgba(255,255,255,.35);
+  }
+  .panel-head {
+    padding: 16px 20px 13px; border-bottom: 1px solid var(--rule);
+    display: flex; align-items: baseline; justify-content: space-between;
+  }
+  .panel-label {
+    font-family: 'IBM Plex Mono', monospace; font-size: 11px;
+    text-transform: uppercase; letter-spacing: .2em; color: var(--ink-soft);
+  }
+  .panel-meta { font-family:'IBM Plex Mono',monospace; font-size: 11px; color: var(--ink-soft); }
+  .panel-body { flex: 1; overflow-y: auto; padding: 20px; }
+  /* ---- left: setup ---- */
+  .dropzone {
+    border: 1.5px dashed var(--rule-strong); border-radius: 3px;
+    padding: 28px 18px; text-align: center; cursor: pointer; transition: .15s;
+    background: var(--paper-inset);
+  }
+  .dropzone:hover, .dropzone.drag { border-color: var(--crit); background: #e9e2d8; }
+  .dropzone .big {
+    font-family:'Newsreader',serif; font-size: 19px; margin-bottom: 4px;
+  }
+  .dropzone .small { font-size: 13px; color: var(--ink-soft); }
+  .or {
+    text-align: center; font-family:'IBM Plex Mono',monospace; font-size: 11px;
+    letter-spacing: .18em; text-transform: uppercase; color: var(--ink-soft);
+    margin: 16px 0 12px; position: relative;
+  }
+  textarea#paste {
+    width: 100%; min-height: 120px; resize: vertical; padding: 12px 14px;
+    border: 1px solid var(--rule-strong); border-radius: 3px; background: var(--paper-inset);
+    font-family: 'Inter', sans-serif; font-size: 14px; color: var(--ink); line-height: 1.5;
+  }
+  textarea#paste:focus { outline: none; border-color: var(--mech); }
+  .btn {
+    font-family:'IBM Plex Mono',monospace; font-size: 12px; letter-spacing: .12em;
+    text-transform: uppercase; cursor: pointer; transition: .15s;
+    background: var(--ink); color: var(--paper); border: none; padding: 12px 18px;
+    border-radius: 3px;
+  }
+  .btn:hover { background: #000; }
+  .btn:disabled { opacity: .45; cursor: default; }
+  .btn-block { width: 100%; margin-top: 14px; }
+  .filename { font-size: 13px; color: var(--crit-ink); margin-top: 10px; font-weight: 500; }
+  /* ---- left: coverage map (signature) ---- */
+  .legend { display: flex; gap: 14px; margin-bottom: 18px; }
+  .legend span { display: flex; align-items: center; gap: 6px; font-size: 11px; color: var(--ink-soft);
+    font-family:'IBM Plex Mono',monospace; letter-spacing: .04em; }
+  .chip { width: 11px; height: 11px; border-radius: 2px; display: inline-block; }
+  .chip.s { background: var(--surface); }
+  .chip.m { background: var(--mech); }
+  .chip.c { background: var(--crit); }
+  .concept { padding: 11px 0; border-bottom: 1px solid var(--rule); }
+  .concept:last-child { border-bottom: none; }
+  .concept-name { font-size: 14px; margin-bottom: 7px; font-weight: 500; }
+  .depth { display: flex; gap: 4px; }
+  .seg {
+    flex: 1; height: 7px; border-radius: 2px; border: 1px solid var(--rule-strong);
+    background: transparent; transition: .35s;
+  }
+  .seg.lit.s { background: var(--surface); border-color: var(--surface); }
+  .seg.lit.m { background: var(--mech); border-color: var(--mech); }
+  .seg.lit.c { background: var(--crit); border-color: var(--crit); }
+  .seg.pulse { animation: pulse .6s ease; }
+  @keyframes pulse { 0%{transform:scaleY(1)} 40%{transform:scaleY(2.1)} 100%{transform:scaleY(1)} }
+  /* ---- right: dialogue ---- */
+  .dialogue { display: flex; flex-direction: column; height: 100%; min-height: 0; overflow: hidden; }
+  .transcript { flex: 1; min-height: 0; overflow-y: auto; padding: 22px 22px 8px; }
+  .empty {
+    height: 100%; display: flex; flex-direction: column; align-items: center;
+    justify-content: center; text-align: center; color: var(--ink-soft); padding: 30px;
+  }
+  .empty .lead { font-family:'Newsreader',serif; font-size: 22px; color: var(--ink); margin-bottom: 8px; font-style: italic; }
+  .empty .sub { font-size: 14px; max-width: 320px; }
+  .turn { margin-bottom: 20px; max-width: 88%; }
+  .turn.student { margin-left: auto; }
+  .turn .who {
+    font-family:'IBM Plex Mono',monospace; font-size: 10px; text-transform: uppercase;
+    letter-spacing: .16em; color: var(--ink-soft); margin-bottom: 5px;
+    display: flex; gap: 8px; align-items: center;
+  }
+  .turn.student .who { justify-content: flex-end; }
+  .bubble {
+    padding: 12px 15px; border-radius: 3px; font-size: 14.5px; line-height: 1.6;
+    white-space: pre-wrap;
+  }
+  .turn.student .bubble { background: var(--ink); color: var(--paper); }
+  .turn.expert .bubble { background: var(--paper-inset); border: 1px solid var(--rule); }
+  .bubble.md p { margin: 0 0 8px; }
+  .bubble.md p:last-child { margin-bottom: 0; }
+  .bubble.md ul, .bubble.md ol { margin: 6px 0 8px 20px; }
+  .bubble.md li { margin: 2px 0; }
+  .bubble.md strong { font-weight: 600; }
+  .bubble.md code {
+    font-family: 'IBM Plex Mono', monospace; font-size: 13px;
+    background: rgba(34,38,46,.08); padding: 1px 5px; border-radius: 3px;
+  }
+  .bubble.md pre {
+    background: rgba(34,38,46,.06); padding: 10px 12px; border-radius: 3px;
+    overflow-x: auto; margin: 6px 0;
+  }
+  .bubble.md pre code { background: none; padding: 0; }
+  .bubble.md h1, .bubble.md h2, .bubble.md h3 {
+    font-family: 'Newsreader', serif; font-size: 16px; margin: 8px 0 4px;
+  }
+  .badge {
+    font-family:'IBM Plex Mono',monospace; font-size: 9.5px; font-weight: 600;
+    letter-spacing: .08em; padding: 2px 6px; border-radius: 2px; color: #fff;
+  }
+  .badge.Surface { background: var(--surface); color: #1f3a47; }
+  .badge.Mechanistic { background: var(--mech); }
+  .badge.Critical { background: var(--crit); }
+  .concept-tag { color: var(--ink-soft); font-style: normal; }
+  .thinking { font-style: italic; color: var(--ink-soft); font-size: 14px; }
+  .dot-flash::after { content: "…"; animation: dots 1.2s steps(4,end) infinite; }
+  @keyframes dots { 0%{content:""} 25%{content:"."} 50%{content:".."} 75%{content:"…"} }
+  .composer {
+    border-top: 1px solid var(--rule); padding: 14px 18px;
+    display: flex; gap: 10px; align-items: flex-end; background: var(--paper);
+    flex-shrink: 0;
+  }
+  .composer textarea {
+    flex: 1; resize: none; height: 44px; max-height: 120px; padding: 11px 13px;
+    border: 1px solid var(--rule-strong); border-radius: 3px; background: var(--paper-inset);
+    font-family: 'Inter', sans-serif; font-size: 14.5px; color: var(--ink); line-height: 1.4;
+  }
+  .composer textarea:focus { outline: none; border-color: var(--mech); }
+  .errline { color: var(--crit-ink); font-size: 13px; margin-top: 10px; }
+  .hidden { display: none !important; }
+  ::-webkit-scrollbar { width: 9px; }
+  ::-webkit-scrollbar-thumb { background: var(--rule-strong); border-radius: 4px; }
+  @media (max-width: 860px) {
+    .workspace { grid-template-columns: 1fr; height: auto; }
+    .panel.left { min-height: 340px; }
+    .panel.right { min-height: 520px; }
+  }
+</style>
+</head>
+<body>
+  <header>
+    <div>
+      <div class="wordmark">Dialectica<span class="dot">.</span></div>
+    </div>
+    <div class="tagline">you ask · the expert answers · depth is measured</div>
+    <div class="provider-pick">
+      <label>Expert</label>
+      <div class="seg-toggle" id="providerToggle">
+        <button data-provider="deepseek" class="active">DeepSeek</button>
+        <button data-provider="gemini">Gemini</button>
+      </div>
+    </div>
+    <button class="reset hidden" id="resetBtn">New material</button>
+  </header>
+  <div class="workspace">
+    <!-- LEFT -->
+    <section class="panel left">
+      <div class="panel-head">
+        <span class="panel-label" id="leftLabel">Material</span>
+        <span class="panel-meta" id="leftMeta"></span>
+      </div>
+      <div class="panel-body" id="leftBody">
+        <!-- setup state -->
+        <div id="setup">
+          <div class="dropzone" id="dropzone">
+            <div class="big">Drop your lecture material</div>
+            <div class="small">PDF · PPTX · DOCX · TXT</div>
+            <input type="file" id="fileInput" class="hidden" accept=".pdf,.pptx,.docx,.txt,.md">
+          </div>
+          <div class="filename hidden" id="filename"></div>
+          <div class="or">— or paste —</div>
+          <textarea id="paste" placeholder="Paste notes, a chapter, slides text…"></textarea>
+          <button class="btn btn-block" id="loadBtn">Load material</button>
+          <div class="errline hidden" id="setupErr"></div>
+        </div>
+        <!-- coverage state -->
+        <div id="coverage" class="hidden">
+          <div class="legend">
+            <span><i class="chip s"></i>Surface</span>
+            <span><i class="chip m"></i>Mechanistic</span>
+            <span><i class="chip c"></i>Critical</span>
+          </div>
+          <div id="conceptList"></div>
+        </div>
+      </div>
+    </section>
+    <!-- RIGHT -->
+    <section class="panel right">
+      <div class="panel-head">
+        <span class="panel-label">The interrogation</span>
+        <span class="panel-meta" id="rightMeta"></span>
+      </div>
+      <div class="dialogue">
+        <div class="transcript" id="transcript">
+          <div class="empty" id="emptyState">
+            <div class="lead">"Know thyself by questioning."</div>
+            <div class="sub">Load material on the left, then put the expert under
+              pressure. Every question you ask is scored for its cognitive depth.</div>
+          </div>
+        </div>
+        <div class="composer hidden" id="composer">
+          <textarea id="qInput" placeholder="Put a question to the expert…" rows="1"></textarea>
+          <button class="btn" id="askBtn">Ask</button>
+        </div>
+      </div>
+    </section>
+  </div>
+<script>
+const LEVELS = ["Surface", "Mechanistic", "Critical"];
+const SEG_CLASS = { Surface: "s", Mechanistic: "m", Critical: "c" };
+let selectedFile = null;
+let provider = "deepseek";
+const $ = (id) => document.getElementById(id);
+// ---- provider toggle ----
+document.querySelectorAll("#providerToggle button").forEach((btn) => {
+  btn.addEventListener("click", () => {
+    document.querySelectorAll("#providerToggle button").forEach((b) =>
+      b.classList.remove("active"));
+    btn.classList.add("active");
+    provider = btn.dataset.provider;
+  });
+});
+// ---- material loading ----
+$("dropzone").addEventListener("click", () => $("fileInput").click());
+$("fileInput").addEventListener("change", (e) => {
+  selectedFile = e.target.files[0] || null;
+  if (selectedFile) {
+    $("filename").textContent = "Selected: " + selectedFile.name;
+    $("filename").classList.remove("hidden");
+  }
+});
+["dragover", "dragleave", "drop"].forEach(evt =>
+  $("dropzone").addEventListener(evt, (e) => {
+    e.preventDefault();
+    $("dropzone").classList.toggle("drag", evt === "dragover");
+    if (evt === "drop" && e.dataTransfer.files[0]) {
+      selectedFile = e.dataTransfer.files[0];
+      $("filename").textContent = "Selected: " + selectedFile.name;
+      $("filename").classList.remove("hidden");
+    }
+  })
+);
+$("loadBtn").addEventListener("click", loadMaterial);
+async function loadMaterial() {
+  const paste = $("paste").value.trim();
+  if (!selectedFile && !paste) {
+    return showSetupErr("Choose a file or paste some text first.");
+  }
+  setLoading(true, "Reading material…");
+  const form = new FormData();
+  if (selectedFile) form.append("file", selectedFile);
+  else form.append("text", paste);
+  form.append("provider", provider);
+  try {
+    const res = await fetch("/api/upload", { method: "POST", body: form });
+    const data = await res.json();
+    if (!res.ok) { setLoading(false); return showSetupErr(data.error || "Could not read that."); }
+    enterInterrogation(data);
+  } catch (err) {
+    setLoading(false);
+    showSetupErr("Could not reach the server. Is it running?");
+  }
+}
+function setLoading(on, label) {
+  $("loadBtn").disabled = on;
+  $("loadBtn").textContent = on ? (label || "Working…") : "Load material";
+}
+function showSetupErr(msg) {
+  $("setupErr").textContent = msg;
+  $("setupErr").classList.remove("hidden");
+}
+// ---- enter interrogation ----
+function enterInterrogation(data) {
+  setLoading(false);
+  $("setup").classList.add("hidden");
+  $("coverage").classList.remove("hidden");
+  $("leftLabel").textContent = "Coverage map";
+  $("leftMeta").textContent = data.char_count.toLocaleString() + " chars";
+  $("resetBtn").classList.remove("hidden");
+  $("emptyState").classList.add("hidden");
+  $("composer").classList.remove("hidden");
+  renderConcepts(data.concepts, data.coverage);
+  $("rightMeta").textContent = data.concepts.length + " concepts in play";
+  $("qInput").focus();
+}
+function renderConcepts(concepts, coverage) {
+  const list = $("conceptList");
+  list.innerHTML = "";
+  concepts.forEach((c) => {
+    const row = document.createElement("div");
+    row.className = "concept";
+    const cov = coverage[c] || {};
+    const segs = LEVELS.map((lv) => {
+      const lit = cov[lv] > 0 ? "lit" : "";
+      return `<span class="seg ${SEG_CLASS[lv]} ${lit}" data-concept="${encodeURIComponent(c)}" data-level="${lv}"></span>`;
+    }).join("");
+    row.innerHTML = `<div class="concept-name">${c}</div><div class="depth">${segs}</div>`;
+    list.appendChild(row);
+  });
+}
+function updateCoverage(coverage) {
+  document.querySelectorAll(".seg").forEach((seg) => {
+    const c = decodeURIComponent(seg.dataset.concept);
+    const lv = seg.dataset.level;
+    const reached = coverage[c] && coverage[c][lv] > 0;
+    if (reached && !seg.classList.contains("lit")) {
+      seg.classList.add("lit", "pulse");
+      setTimeout(() => seg.classList.remove("pulse"), 600);
+    }
+  });
+}
+// ---- asking ----
+$("askBtn").addEventListener("click", ask);
+$("qInput").addEventListener("keydown", (e) => {
+  if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); ask(); }
+});
+async function ask() {
+  const q = $("qInput").value.trim();
+  if (!q) return;
+  $("qInput").value = "";
+  addStudentTurn(q);
+  const thinkingEl = addThinking();
+  $("askBtn").disabled = true;
+  try {
+    const res = await fetch("/api/ask", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ question: q, provider: provider }),
+    });
+    const data = await res.json();
+    thinkingEl.remove();
+    if (!res.ok) { addExpertTurn(data.error || "Something went wrong."); }
+    else {
+      tagLastStudent(data.level, data.confidence, data.concept);
+      addExpertTurn(data.answer);
+      updateCoverage(data.coverage);
+    }
+  } catch (err) {
+    thinkingEl.remove();
+    addExpertTurn("Could not reach the server.");
+  }
+  $("askBtn").disabled = false;
+  $("qInput").focus();
+}
+function scrollDown() { const t = $("transcript"); t.scrollTop = t.scrollHeight; }
+let lastStudentEl = null;
+function addStudentTurn(text) {
+  const el = document.createElement("div");
+  el.className = "turn student";
+  el.innerHTML = `<div class="who"><span class="pending mono">scoring…</span> You</div>
+    <div class="bubble"></div>`;
+  el.querySelector(".bubble").textContent = text;
+  $("transcript").appendChild(el);
+  lastStudentEl = el;
+  scrollDown();
+}
+function tagLastStudent(level, conf, concept) {
+  if (!lastStudentEl) return;
+  const pct = Math.round(conf * 100);
+  const conceptBit = concept ? ` · <span class="concept-tag">${concept}</span>` : "";
+  lastStudentEl.querySelector(".who").innerHTML =
+    `<span class="badge ${level}">${level.toUpperCase()} ${pct}%</span>${conceptBit} You`;
+}
+function addThinking() {
+  const el = document.createElement("div");
+  el.className = "turn expert";
+  el.innerHTML = `<div class="who">The expert</div>
+    <div class="bubble thinking"><span class="dot-flash">considering</span></div>`;
+  $("transcript").appendChild(el);
+  scrollDown();
+  return el;
+}
+function addExpertTurn(text) {
+  const el = document.createElement("div");
+  el.className = "turn expert";
+  el.innerHTML = `<div class="who">The expert</div><div class="bubble md"></div>`;
+  const bubble = el.querySelector(".bubble");
+  if (window.marked) {
+    bubble.innerHTML = marked.parse(text);
+  } else {
+    bubble.textContent = text;
+  }
+  $("transcript").appendChild(el);
+  scrollDown();
+}
+// ---- reset ----
+$("resetBtn").addEventListener("click", () => location.reload());
+// auto-grow question box
+$("qInput").addEventListener("input", function () {
+  this.style.height = "44px";
+  this.style.height = Math.min(this.scrollHeight, 120) + "px";
+});
+</script>
+</body>
+</html>

main.py CHANGED Viewed

@@ -1,13 +1,177 @@
-"""Application entry point.
-Phase 8 app code will be added here.
 """
-def main():
-    """Placeholder for app startup."""
-    raise NotImplementedError("Phase 8: application layer not yet implemented.")
-if __name__ == "__main__":
-    main()

+"""FastAPI backend for Dialectica.
+Endpoints:
+    GET  /              serve the frontend
+    POST /api/upload    parse material, extract concepts, init session
+    POST /api/ask       classify question, get expert answer, update coverage
+    GET  /api/coverage  current coverage map
+Run locally:
+    PYTORCH_ENABLE_MPS_FALLBACK=1 uvicorn main:app
 """
+import os
+from dotenv import load_dotenv
+from fastapi import FastAPI, File, Form, UploadFile
+from fastapi.responses import FileResponse, JSONResponse
+from pydantic import BaseModel
+import config
+from scripts import parsing
+from scripts.expert import Expert
+from scripts.inference import ORDERED_LABELS, CognitiveClassifier, ConceptMatcher
+load_dotenv()
+app = FastAPI(title="Dialectica")
+VALID_PROVIDERS = ("deepseek", "gemini")
+# In-memory session state for the demo.
+SESSION = {
+    "material": "",
+    "concepts": [],
+    "coverage": {},   # concept -> {Surface: n, Mechanistic: n, Critical: n}
+    "history": [],
+}
+# Shared classifier/matcher; one cached expert per provider.
+COMPONENTS = {"classifier": None, "matcher": None, "experts": {}}
+def get_classifier_and_matcher():
+    """Initialize classifier and matcher on first use."""
+    product_config = config.ProductConfig()
+    if COMPONENTS["classifier"] is None:
+        COMPONENTS["classifier"] = CognitiveClassifier(product_config)
+    if COMPONENTS["matcher"] is None:
+        COMPONENTS["matcher"] = ConceptMatcher(product_config)
+    return COMPONENTS["classifier"], COMPONENTS["matcher"]
+def get_expert(provider):
+    """Return a cached expert for the given provider, or an error string."""
+    if provider not in VALID_PROVIDERS:
+        provider = "deepseek"
+    if provider not in COMPONENTS["experts"]:
+        product_config = config.ProductConfig()
+        product_config.provider = provider
+        try:
+            COMPONENTS["experts"][provider] = Expert(product_config)
+        except SystemExit as error:
+            return None, str(error)
+        except Exception as error:  # missing SDK, bad key shape, etc.
+            return None, f"Could not start the {provider} expert: {error}"
+    return COMPONENTS["experts"][provider], None
+def _blank_coverage(concepts):
+    """Initialise an empty coverage record for each concept."""
+    return {c: {level: 0 for level in ORDERED_LABELS} for c in concepts}
+class AskRequest(BaseModel):
+    """Body for the /api/ask endpoint."""
+    question: str
+    provider: str = "deepseek"
+@app.get("/")
+def index():
+    """Serve the single-page frontend."""
+    return FileResponse(os.path.join("frontend", "index.html"))
+@app.post("/api/upload")
+async def upload(
+    file: UploadFile = File(None),
+    text: str = Form(None),
+    provider: str = Form("deepseek"),
+):
+    """Parse uploaded material or pasted text and extract concepts."""
+    if file is not None:
+        data = await file.read()
+        try:
+            raw = parsing.parse_material(file.filename, data)
+        except ValueError as error:
+            return JSONResponse(status_code=400, content={"error": str(error)})
+    elif text:
+        raw = text
+    else:
+        return JSONResponse(
+            status_code=400,
+            content={"error": "Upload a file or paste some text to begin."},
+        )
+    material = parsing.clean_text(raw)
+    if len(material) < 40:
+        return JSONResponse(
+            status_code=400,
+            content={"error": "That material is too short to work with."},
+        )
+    _, matcher = get_classifier_and_matcher()
+    expert, error = get_expert(provider)
+    if expert is None:
+        return JSONResponse(status_code=400, content={"error": error})
+    concepts = expert.extract_concepts(material)
+    matcher.set_concepts(concepts)
+    SESSION["material"] = material
+    SESSION["concepts"] = concepts
+    SESSION["coverage"] = _blank_coverage(concepts)
+    SESSION["history"] = []
+    return {"concepts": concepts, "coverage": SESSION["coverage"],
+            "char_count": len(material), "provider": provider}
+@app.post("/api/ask")
+def ask(request: AskRequest):
+    """Classify the question, answer as the expert, and update coverage."""
+    question = request.question.strip()
+    if not question:
+        return JSONResponse(status_code=400,
+                            content={"error": "Ask the expert something."})
+    if not SESSION["material"]:
+        return JSONResponse(
+            status_code=400,
+            content={"error": "Load some material before you start asking."},
+        )
+    classifier, matcher = get_classifier_and_matcher()
+    expert, error = get_expert(request.provider)
+    if expert is None:
+        return JSONResponse(status_code=400, content={"error": error})
+    classification = classifier.classify(question)
+    level = classification["level"]
+    concept = matcher.match(question)
+    answer_text = expert.answer(
+        question, SESSION["material"], SESSION["history"]
+    )
+    SESSION["history"].append({"role": "student", "text": question})
+    SESSION["history"].append({"role": "expert", "text": answer_text})
+    if concept and concept in SESSION["coverage"]:
+        SESSION["coverage"][concept][level] += 1
+    return {
+        "answer": answer_text,
+        "level": level,
+        "confidence": classification["confidence"],
+        "concept": concept,
+        "coverage": SESSION["coverage"],
+        "provider": request.provider,
+    }
+@app.get("/api/coverage")
+def coverage():
+    """Return the current coverage map and concept list."""
+    return {"concepts": SESSION["concepts"], "coverage": SESSION["coverage"]}

requirements-app.txt ADDED Viewed

	@@ -0,0 +1,24 @@

+# Runtime dependencies for the deployed Dialectica app only.
+# Training-only packages (scikit-learn, datasets, matplotlib, seaborn, pandas)
+# are intentionally omitted to keep the image small and the build fast.
+fastapi>=0.110.0
+uvicorn[standard]>=0.29.0
+python-multipart>=0.0.9
+python-dotenv>=1.0.0
+# classifier (live inference)
+transformers>=4.44.0
+# torch is installed separately (CPU build) in the Dockerfile
+# concept matching
+sentence-transformers>=3.0.0
+# expert dialogue providers
+openai>=1.40.0
+google-genai>=1.0.0
+# material parsing
+pymupdf>=1.24.0
+python-pptx>=0.6.23
+python-docx>=1.1.0

requirements.txt CHANGED Viewed

@@ -18,8 +18,10 @@ datasets>=2.20.0
 matplotlib>=3.8.0
 seaborn>=0.13.0
-# Product backend (Phase 8, added later)
-# fastapi>=0.110.0
-# uvicorn>=0.29.0
-# pymupdf>=1.24.0
-# python-pptx>=0.6.23

 matplotlib>=3.8.0
 seaborn>=0.13.0
+# Product backend (Phase 8)
+fastapi>=0.110.0
+uvicorn[standard]>=0.29.0
+python-multipart>=0.0.9
+pymupdf>=1.24.0
+python-pptx>=0.6.23
+python-docx>=1.1.0

scripts/expert.py ADDED Viewed

	@@ -0,0 +1,164 @@

+"""Gemini/DeepSeek-backed expert for concept extraction and student dialogue."""
+import json
+import os
+EXPERT_SYSTEM_PROMPT = """You are a knowledgeable subject-matter expert on the \
+study material provided below. A student is going to question, probe, and \
+challenge you in order to deepen their own understanding. You are not a tutor \
+who quizzes them; they lead the inquiry.
+Rules:
+- Answer directly and substantively, grounded in the material. Do not pad.
+- Match the student's depth. A plain factual question gets a plain answer; a \
+question that probes mechanism or challenges an assumption gets a deeper, \
+reasoned response.
+- When the student challenges you or surfaces a genuine edge case, limitation, \
+or counterexample, acknowledge it honestly and engage with it. Do not be \
+defensive, and do not pretend the material is more complete than it is.
+- If they ask something the material does not cover, say so plainly and reason \
+from first principles, flagging that you are going beyond the source.
+- Never quiz the student back or end with "does that make sense?". They are the \
+one asking the questions.
+- You may use light markdown (bold, lists) when it aids clarity.
+Study material:
+---
+{material}
+---
+"""
+CONCEPT_PROMPT = """From the study material below, extract the {n} most \
+important distinct concepts or topics a student would want to understand. \
+Return a JSON object with a single key "concepts" whose value is an array of \
+short concept names (2-5 words each), ordered from most to least central.
+Material:
+---
+{material}
+---
+Return only the JSON object."""
+class Expert:
+    """Concept extraction and expert dialogue, via DeepSeek or Gemini."""
+    def __init__(self, product_config):
+        """Initialise the client for the configured provider."""
+        self.cfg = product_config
+        self.provider = getattr(product_config, "provider", "deepseek")
+        if self.provider == "deepseek":
+            self._init_deepseek()
+        elif self.provider == "gemini":
+            self._init_gemini()
+        else:
+            raise ValueError(f"Unknown provider: {self.provider}")
+    def _init_deepseek(self):
+        """Set up the DeepSeek (OpenAI-compatible) client."""
+        from openai import OpenAI
+        api_key = os.environ.get("DEEPSEEK_API_KEY")
+        if not api_key:
+            raise SystemExit(
+                "DEEPSEEK_API_KEY is not set. Add it to .env, or set "
+                "ProductConfig.provider = 'gemini' to use Gemini instead."
+            )
+        self.client = OpenAI(api_key=api_key, base_url="https://api.deepseek.com")
+        self.model = self.cfg.deepseek_model
+    def _init_gemini(self):
+        """Set up the Gemini client."""
+        from google import genai
+        api_key = os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            raise SystemExit("GEMINI_API_KEY is not set. Add it to .env.")
+        self.client = genai.Client(api_key=api_key)
+        self.model = self.cfg.gemini_model
+    # ---- concept extraction ----
+    def extract_concepts(self, material_text):
+        """Ask the model for the key concepts in the material."""
+        material = material_text[: self.cfg.max_context_chars]
+        prompt = CONCEPT_PROMPT.format(n=self.cfg.num_concepts, material=material)
+        if self.provider == "deepseek":
+            raw = self._deepseek_json(prompt)
+        else:
+            raw = self._gemini_json(prompt)
+        try:
+            parsed = json.loads(raw)
+            concepts = parsed.get("concepts", []) if isinstance(parsed, dict) else []
+        except (json.JSONDecodeError, TypeError):
+            concepts = []
+        return [c.strip() for c in concepts if isinstance(c, str) and c.strip()]
+    def _deepseek_json(self, prompt):
+        """One DeepSeek call returning a JSON object string."""
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=[{"role": "user", "content": prompt}],
+            response_format={"type": "json_object"},
+            temperature=0.3,
+        )
+        return response.choices[0].message.content
+    def _gemini_json(self, prompt):
+        """One Gemini call returning a JSON object string."""
+        from google.genai import types
+        response = self.client.models.generate_content(
+            model=self.model,
+            contents=prompt,
+            config=types.GenerateContentConfig(
+                response_mime_type="application/json",
+                temperature=0.3,
+            ),
+        )
+        return response.text
+    # ---- expert dialogue ----
+    def answer(self, question, material_text, history):
+        """Answer a student question given material context and chat history."""
+        material = material_text[: self.cfg.max_context_chars]
+        system = EXPERT_SYSTEM_PROMPT.format(material=material)
+        if self.provider == "deepseek":
+            return self._deepseek_answer(system, question, history)
+        return self._gemini_answer(system, question, history)
+    def _deepseek_answer(self, system, question, history):
+        """Send question to DeepSeek and return the answer."""
+        messages = [{"role": "system", "content": system}]
+        for turn in history[-8:]:
+            role = "user" if turn["role"] == "student" else "assistant"
+            messages.append({"role": role, "content": turn["text"]})
+        messages.append({"role": "user", "content": question})
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=messages,
+            temperature=0.7,
+        )
+        return response.choices[0].message.content.strip()
+    def _gemini_answer(self, system, question, history):
+        """Send question to Gemini and return the answer."""
+        from google.genai import types
+        transcript = []
+        for turn in history[-8:]:
+            speaker = "Student" if turn["role"] == "student" else "Expert"
+            transcript.append(f"{speaker}: {turn['text']}")
+        transcript.append(f"Student: {question}")
+        conversation = "\n\n".join(transcript)
+        response = self.client.models.generate_content(
+            model=self.model,
+            contents=conversation,
+            config=types.GenerateContentConfig(
+                system_instruction=system,
+                temperature=0.7,
+            ),
+        )
+        return response.text.strip()

scripts/inference.py ADDED Viewed

	@@ -0,0 +1,95 @@

+"""Inference for the Dialectica app.
+Two jobs:
+  1. Classify the cognitive level of a student question in real time, using the
+     DistilBERT model fine-tuned in Phase 4b. This is the trained model running
+     live inference in the deployed product, satisfying the rubric requirement.
+  2. Match a question to the nearest extracted concept via sentence-embedding
+     similarity, so the coverage map knows which concept the question advanced.
+Both models load once at startup.
+Author: Keming Zhang
+Note: Drafted with assistance from Claude (Anthropic). Uses the fine-tuned
+DistilBERT classifier and sentence-transformers for concept matching.
+"""
+ORDERED_LABELS = ["Surface", "Mechanistic", "Critical"]
+class CognitiveClassifier:
+    """Wraps the fine-tuned DistilBERT for live question classification."""
+    def __init__(self, product_config):
+        """Load the classifier and tokenizer from disk."""
+        import torch
+        from transformers import (
+            AutoModelForSequenceClassification,
+            AutoTokenizer,
+        )
+        self.cfg = product_config
+        self.torch = torch
+        self.tokenizer = AutoTokenizer.from_pretrained(self.cfg.classifier_dir)
+        self.model = AutoModelForSequenceClassification.from_pretrained(
+            self.cfg.classifier_dir
+        )
+        self.model.eval()
+        # use the model's own id2label if present, else fall back to ordered
+        self.id2label = self.model.config.id2label or {
+            i: label for i, label in enumerate(ORDERED_LABELS)
+        }
+    def classify(self, question):
+        """Return the predicted level and a confidence score for one question."""
+        inputs = self.tokenizer(
+            question,
+            truncation=True,
+            max_length=self.cfg.max_question_length,
+            return_tensors="pt",
+        )
+        with self.torch.no_grad():
+            logits = self.model(**inputs).logits
+            probs = self.torch.softmax(logits, dim=1)[0]
+        predicted_id = int(self.torch.argmax(probs))
+        return {
+            "level": self.id2label[predicted_id],
+            "confidence": float(probs[predicted_id]),
+        }
+class ConceptMatcher:
+    """Matches a question to the nearest concept by embedding similarity."""
+    def __init__(self, product_config):
+        """Load the sentence embedding model."""
+        from sentence_transformers import SentenceTransformer
+        self.cfg = product_config
+        self.model = SentenceTransformer(self.cfg.embed_model)
+        self.concepts = []
+        self.concept_embeddings = None
+    def set_concepts(self, concepts):
+        """Embed and store the current material's concept list."""
+        self.concepts = concepts
+        if concepts:
+            self.concept_embeddings = self.model.encode(
+                concepts, convert_to_tensor=True
+            )
+        else:
+            self.concept_embeddings = None
+    def match(self, question):
+        """Return the best-matching concept, or None if below threshold."""
+        from sentence_transformers import util
+        if not self.concepts or self.concept_embeddings is None:
+            return None
+        query = self.model.encode(question, convert_to_tensor=True)
+        scores = util.cos_sim(query, self.concept_embeddings)[0]
+        best_index = int(scores.argmax())
+        best_score = float(scores[best_index])
+        if best_score < self.cfg.concept_match_threshold:
+            return None
+        return self.concepts[best_index]

scripts/parsing.py ADDED Viewed

	@@ -0,0 +1,63 @@

+"""Parse uploaded course material into plain text.
+Supports PDF, PPTX, DOCX, and plain text files.
+"""
+import io
+def parse_pdf(data):
+    """Extract text from PDF bytes using PyMuPDF."""
+    import fitz  # PyMuPDF
+    text_parts = []
+    with fitz.open(stream=data, filetype="pdf") as document:
+        for page in document:
+            text_parts.append(page.get_text())
+    return "\n".join(text_parts)
+def parse_pptx(data):
+    """Extract text from PPTX bytes, slide by slide."""
+    from pptx import Presentation
+    presentation = Presentation(io.BytesIO(data))
+    text_parts = []
+    for index, slide in enumerate(presentation.slides, start=1):
+        text_parts.append(f"[Slide {index}]")
+        for shape in slide.shapes:
+            if shape.has_text_frame:
+                for paragraph in shape.text_frame.paragraphs:
+                    line = "".join(run.text for run in paragraph.runs)
+                    if line.strip():
+                        text_parts.append(line)
+    return "\n".join(text_parts)
+def parse_docx(data):
+    """Extract text from DOCX bytes."""
+    from docx import Document
+    document = Document(io.BytesIO(data))
+    return "\n".join(p.text for p in document.paragraphs if p.text.strip())
+def parse_material(filename, data):
+    """Pick the right parser based on file extension and return plain text."""
+    lower = filename.lower()
+    if lower.endswith(".pdf"):
+        return parse_pdf(data)
+    if lower.endswith(".pptx"):
+        return parse_pptx(data)
+    if lower.endswith(".docx"):
+        return parse_docx(data)
+    if lower.endswith(".txt") or lower.endswith(".md"):
+        return data.decode("utf-8", errors="ignore")
+    raise ValueError(f"Unsupported file type: {filename}")
+def clean_text(text):
+    """Strip extra whitespace and blank lines."""
+    lines = [line.strip() for line in text.splitlines()]
+    non_empty = [line for line in lines if line]
+    return "\n".join(non_empty)