Inmemory

.dockerignore

@@ -0,0 +1,12 @@
+.git
+.venv
+.env
+__pycache__
+*.pyc
+*.db
+.claude
+CLAUDE.md
+AGENTS.md
+my-notes
+docs
+*.ipynb

Dockerfile

@@ -0,0 +1,32 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+# Install system dependencies required by torch and transformers
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install CPU-only torch first to keep image lean, then remaining deps
+COPY requirements.txt .
+RUN pip install --no-cache-dir torch>=2.2.0 --index-url https://download.pytorch.org/whl/cpu \
+    && pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY app.py config.py ./
+COPY core/ core/
+COPY db/ db/
+COPY models/ models/
+COPY ui/ ui/
+
+# HuggingFace model cache is stored under /data so it can be mounted as a
+# volume and downloaded weights survive container restarts.
+ENV HF_HOME=/data/hf_cache \
+    PORT=7860
+
+VOLUME /data
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

app.py

@@ -1,6 +1,5 @@
 import gradio as gr
 import config
-from db.store import init_db
 from models.model_loader import get_llm, get_embedder
 from ui.compress_tab import build_compress_tab
 from ui.history_tab import build_history_tab
@@ -8,15 +7,13 @@ from ui.history_tab import build_history_tab
 
 def build_app() -> gr.Blocks:
     with gr.Blocks(title=config.APP_TITLE) as app:
-        build_compress_tab()
-        build_history_tab()
+        run_store = gr.State(value=[])
+        build_compress_tab(run_store)
+        build_history_tab(run_store)
     return app
 
 
 if __name__ == "__main__":
-    print("Initialising database...")
-    init_db()
-
     print("Loading models (first run may download weights)...")
     get_llm()
     get_embedder()

config.py

@@ -60,9 +60,6 @@ EMBEDDER_INFO = {
 DEFAULT_TARGET_TOKENS = 500
 MAX_NEW_TOKENS = 1024
 
-# Database
-DB_PATH = os.getenv("DB_PATH", "tinypress.db")
-
 # Gradio
 APP_TITLE = "TinyPress"
 SERVER_PORT = int(os.getenv("PORT", 7860))

db/store.py

@@ -1,87 +1,27 @@
-import sqlite3
-import config
-from pathlib import Path
+def make_store() -> list:
+    return []
 
 
-def _connect():
-    conn = sqlite3.connect(config.DB_PATH)
-    conn.row_factory = sqlite3.Row
-    return conn
+def save_run(store: list, record: dict) -> tuple[int, list]:
+    run_id = store[-1]["id"] + 1 if store else 1
+    return run_id, store + [{"id": run_id, **record}]
 
 
-def init_db():
-    schema = Path(__file__).parent / "schema.sql"
-    conn = _connect()
-    conn.executescript(schema.read_text())
-    # Migrate existing databases that pre-date new columns.
-    for col, typedef in [("tokenizer", "TEXT NOT NULL DEFAULT ''"), ("duration_ms", "REAL NOT NULL DEFAULT 0"), ("feedback", "INTEGER"), ("feedback_comment", "TEXT")]:
-        try:
-            conn.execute(f"ALTER TABLE compression_runs ADD COLUMN {col} {typedef}")
-        except sqlite3.OperationalError:
-            pass  # column already exists
-    conn.commit()
-    conn.close()
+def get_runs(store: list, limit: int = 100) -> list[dict]:
+    return list(reversed(store))[:limit]
 
 
-def save_run(record: dict) -> int:
-    conn = _connect()
-    cursor = conn.execute(
-        """
-        INSERT INTO compression_runs
-            (timestamp, model, tokenizer, input_tokens, output_tokens, target_tokens,
-             compression_ratio, quality_score, duration_ms, input_text, output_text)
-        VALUES
-            (:timestamp, :model, :tokenizer, :input_tokens, :output_tokens, :target_tokens,
-             :compression_ratio, :quality_score, :duration_ms, :input_text, :output_text)
-        """,
-        record,
-    )
-    run_id = cursor.lastrowid
-    conn.commit()
-    conn.close()
-    return run_id
+def get_run(store: list, run_id: int) -> dict | None:
+    return next((r for r in store if r["id"] == run_id), None)
 
 
-def update_feedback(run_id: int, value: int):
-    conn = _connect()
-    conn.execute(
-        "UPDATE compression_runs SET feedback = ? WHERE id = ?",
-        (value, run_id),
-    )
-    conn.commit()
-    conn.close()
+def delete_run(store: list, run_id: int) -> list:
+    return [r for r in store if r["id"] != run_id]
 
 
-def update_feedback_comment(run_id: int, comment: str):
-    conn = _connect()
-    conn.execute(
-        "UPDATE compression_runs SET feedback_comment = ? WHERE id = ?",
-        (comment, run_id),
-    )
-    conn.commit()
-    conn.close()
+def update_feedback(store: list, run_id: int, value: int) -> list:
+    return [{**r, "feedback": value} if r["id"] == run_id else r for r in store]
 
 
-def delete_run(run_id: int):
-    conn = _connect()
-    conn.execute("DELETE FROM compression_runs WHERE id = ?", (run_id,))
-    conn.commit()
-    conn.close()
-
-
-def get_run(run_id: int) -> dict | None:
-    conn = _connect()
-    row = conn.execute(
-        "SELECT * FROM compression_runs WHERE id = ?", (run_id,)
-    ).fetchone()
-    conn.close()
-    return dict(row) if row else None
-
-
-def get_runs(limit: int = 100) -> list[dict]:
-    conn = _connect()
-    rows = conn.execute(
-        "SELECT * FROM compression_runs ORDER BY id DESC LIMIT ?", (limit,)
-    ).fetchall()
-    conn.close()
-    return [dict(r) for r in rows]
+def update_feedback_comment(store: list, run_id: int, comment: str) -> list:
+    return [{**r, "feedback_comment": comment} if r["id"] == run_id else r for r in store]

docker-compose.yml

@@ -0,0 +1,19 @@
+networks:
+  hf-build-small:
+    driver: bridge
+
+volumes:
+  tinypress-data:
+
+services:
+  tinypress:
+    build: .
+    ports:
+      - "7860:7860"
+    volumes:
+      - tinypress-data:/data
+    env_file:
+      - .env
+    networks:
+      - hf-build-small
+    restart: unless-stopped

ui/compress_tab.py

@@ -42,7 +42,6 @@ def _render_token_html(text: str) -> str:
     spans = []
     for i, tok in enumerate(tokens):
         color = _PALETTE[i % len(_PALETTE)]
-        # Make leading whitespace visible with a mid-dot; escape everything else.
         display = _h.escape(tok).replace(
             " ", '<span style="opacity:0.35;font-size:0.7em">·</span>'
         )
@@ -112,12 +111,13 @@ def compression_status(text: str, target_tokens: int) -> str:
 
 # ── core handlers ─────────────────────────────────────────────────────────────
 
-def run_compression(text: str, target_tokens: int):
+def run_compression(text: str, target_tokens: int, run_store: list):
     _hidden = gr.update(visible=False)
     if not text.strip():
         return ("", 0, 0, 0, 0.0, None,
                 _hidden, _hidden, gr.update(value="", visible=False),
-                gr.update(value="", visible=False), _hidden, gr.update(value="", visible=False))
+                gr.update(value="", visible=False), _hidden, gr.update(value="", visible=False),
+                run_store)
 
     t0 = time.perf_counter()
     compressed, input_tokens, output_tokens = compress(text, int(target_tokens))
@@ -126,7 +126,7 @@ def run_compression(text: str, target_tokens: int):
     ratio = round(output_tokens / input_tokens, 4) if input_tokens else 0.0
     quality = semantic_score(text, compressed)
 
-    run_id = save_run({
+    run_id, new_store = save_run(run_store, {
         "timestamp": datetime.now(timezone.utc).isoformat(),
         "model": get_current_model_id() or config.LLM_MODEL,
         "tokenizer": get_current_tokenizer_id() or config.LLM_MODEL,
@@ -143,11 +143,12 @@ def run_compression(text: str, target_tokens: int):
     return (
         compressed, input_tokens, output_tokens, ratio, quality,
         run_id,
-        gr.update(visible=True), gr.update(visible=True),    # thumbs buttons
-        gr.update(value="", visible=True),                    # feedback_status
-        gr.update(value="", visible=False),                   # comment_box reset
-        gr.update(visible=False),                             # save_comment_btn reset
-        gr.update(value="", visible=False),                   # comment_saved reset
+        gr.update(visible=True), gr.update(visible=True),
+        gr.update(value="", visible=True),
+        gr.update(value="", visible=False),
+        gr.update(visible=False),
+        gr.update(value="", visible=False),
+        new_store,
     )
 
 
@@ -173,26 +174,28 @@ def on_embedder_change(model_id: str) -> str:
     return config.EMBEDDER_INFO.get(model_id, "")
 
 
-def submit_feedback(run_id, value: int):
+def submit_feedback(run_id, value: int, run_store: list):
     if run_id is None:
-        return "Run a compression first.", gr.update(visible=False), gr.update(visible=False), gr.update(value="", visible=False)
-    update_feedback(run_id, value)
+        return ("Run a compression first.",
+                gr.update(visible=False), gr.update(visible=False),
+                gr.update(value="", visible=False), run_store)
+    new_store = update_feedback(run_store, run_id, value)
     msg = "👍 Marked as helpful — thanks!" if value == 1 else "👎 Noted — thanks for the feedback!"
-    return msg, gr.update(visible=True), gr.update(visible=True), gr.update(value="", visible=False)
+    return msg, gr.update(visible=True), gr.update(visible=True), gr.update(value="", visible=False), new_store
 
 
-def save_comment(run_id, comment: str):
+def save_comment(run_id, comment: str, run_store: list):
     if run_id is None:
-        return gr.update(value="Run a compression first.", visible=True)
+        return gr.update(value="Run a compression first.", visible=True), run_store
     if not comment.strip():
-        return gr.update(value="Type a note first.", visible=True)
-    update_feedback_comment(run_id, comment.strip())
-    return gr.update(value="✓ Note saved.", visible=True)
+        return gr.update(value="Type a note first.", visible=True), run_store
+    new_store = update_feedback_comment(run_store, run_id, comment.strip())
+    return gr.update(value="✓ Note saved.", visible=True), new_store
 
 
 # ── UI ────────────────────────────────────────────────────────────────────────
 
-def build_compress_tab() -> gr.Tab:
+def build_compress_tab(run_store) -> gr.Tab:
     with gr.Tab("Compress") as tab:
         gr.Markdown("## TinyPress — Prompt Compression Engine")
         gr.Markdown(
@@ -303,25 +306,25 @@ def build_compress_tab() -> gr.Tab:
         load_embedder_btn.click(fn=load_embedder, inputs=[embedder_dropdown], outputs=[embedder_status])
         compress_btn.click(
             fn=run_compression,
-            inputs=[input_text, target_slider],
+            inputs=[input_text, target_slider, run_store],
             outputs=[output_text, input_tok, output_tok, ratio, quality,
                      last_run_id, thumbs_up_btn, thumbs_down_btn, feedback_status,
-                     comment_box, save_comment_btn, comment_saved],
+                     comment_box, save_comment_btn, comment_saved, run_store],
         )
         thumbs_up_btn.click(
-            fn=lambda run_id: submit_feedback(run_id, 1),
-            inputs=[last_run_id],
-            outputs=[feedback_status, comment_box, save_comment_btn, comment_saved],
+            fn=lambda run_id, store: submit_feedback(run_id, 1, store),
+            inputs=[last_run_id, run_store],
+            outputs=[feedback_status, comment_box, save_comment_btn, comment_saved, run_store],
         )
         thumbs_down_btn.click(
-            fn=lambda run_id: submit_feedback(run_id, -1),
-            inputs=[last_run_id],
-            outputs=[feedback_status, comment_box, save_comment_btn, comment_saved],
+            fn=lambda run_id, store: submit_feedback(run_id, -1, store),
+            inputs=[last_run_id, run_store],
+            outputs=[feedback_status, comment_box, save_comment_btn, comment_saved, run_store],
         )
         save_comment_btn.click(
             fn=save_comment,
-            inputs=[last_run_id, comment_box],
-            outputs=[comment_saved],
+            inputs=[last_run_id, comment_box, run_store],
+            outputs=[comment_saved, run_store],
         )
 
     return tab

ui/history_tab.py

@@ -11,10 +11,18 @@ _ALL_COLS = [
     "feedback", "feedback_comment",
 ]
 
+_SESSION_WARNING = (
+    '<div style="background:#fef9c3;border:1px solid #eab308;color:#854d0e;'
+    'padding:8px 12px;border-radius:6px;font-size:0.9rem;margin-bottom:4px">'
+    '⚠️ <strong>Session only</strong> — history is stored in memory and will be '
+    'cleared when you close or refresh this page. No data is persisted to disk.'
+    '</div>'
+)
 
-def load_history(selected_cols=None):
+
+def load_history(selected_cols, run_store):
     cols = selected_cols if selected_cols else _DEFAULT_COLS
-    runs = get_runs(limit=100)
+    runs = get_runs(run_store, limit=100)
     if not runs:
         return pd.DataFrame(columns=cols), "", "", ""
     df = pd.DataFrame(runs)
@@ -25,30 +33,31 @@ def load_history(selected_cols=None):
     return df, avg_quality, avg_ratio, ""
 
 
-def on_row_select(evt: gr.SelectData, df: pd.DataFrame):
+def on_row_select(evt: gr.SelectData, df: pd.DataFrame, run_store: list):
     if df is None or df.empty:
         return None, "", "No rows available."
     row_idx = evt.index[0]
     run_id = int(df.iloc[row_idx]["id"])
-    record = get_run(run_id)
+    record = get_run(run_store, run_id)
     if not record:
-        return None, "", f"Row {run_id} not found in database."
+        return None, "", f"Row {run_id} not found."
     diff_html = render_diff_html(record)
     return run_id, diff_html, f"Row {run_id} selected — click Delete to remove."
 
 
-def delete_selected(run_id, selected_cols):
+def delete_selected(run_id, selected_cols, run_store):
     if run_id is None:
-        df, avg_q, avg_r, _ = load_history(selected_cols)
-        return df, avg_q, avg_r, None, "", "No row selected."
-    delete_run(run_id)
-    df, avg_q, avg_r, _ = load_history(selected_cols)
-    return df, avg_q, avg_r, None, "", f"Row {run_id} deleted."
+        df, avg_q, avg_r, _ = load_history(selected_cols, run_store)
+        return df, avg_q, avg_r, None, "", "No row selected.", run_store
+    new_store = delete_run(run_store, run_id)
+    df, avg_q, avg_r, _ = load_history(selected_cols, new_store)
+    return df, avg_q, avg_r, None, "", f"Row {run_id} deleted.", new_store
 
 
-def build_history_tab() -> gr.Tab:
+def build_history_tab(run_store) -> gr.Tab:
     with gr.Tab("History") as tab:
         gr.Markdown("## Compression Run History")
+        gr.HTML(_SESSION_WARNING)
 
         with gr.Row():
             refresh_btn = gr.Button("Refresh", variant="secondary")
@@ -79,18 +88,18 @@ def build_history_tab() -> gr.Tab:
 
         _outputs = [history_table, avg_quality, avg_ratio, diff_panel]
 
-        refresh_btn.click(fn=load_history, inputs=[col_picker], outputs=_outputs)
-        tab.select(fn=load_history, inputs=[col_picker], outputs=_outputs)
-        col_picker.change(fn=load_history, inputs=[col_picker], outputs=_outputs)
+        refresh_btn.click(fn=load_history, inputs=[col_picker, run_store], outputs=_outputs)
+        tab.select(fn=load_history, inputs=[col_picker, run_store], outputs=_outputs)
+        col_picker.change(fn=load_history, inputs=[col_picker, run_store], outputs=_outputs)
         history_table.select(
             fn=on_row_select,
-            inputs=[history_table],
+            inputs=[history_table, run_store],
             outputs=[selected_id, diff_panel, delete_status],
         )
         delete_btn.click(
             fn=delete_selected,
-            inputs=[selected_id, col_picker],
-            outputs=[history_table, avg_quality, avg_ratio, selected_id, diff_panel, delete_status],
+            inputs=[selected_id, col_picker, run_store],
+            outputs=[history_table, avg_quality, avg_ratio, selected_id, diff_panel, delete_status, run_store],
         )
 
     return tab