[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Pakistan Notice Helper", "sdk": "gradio", "declared_models": [], "tags": ["backyard-ai", "build-small-hackathon", "gradio", "llama.cpp", "modal"]}

[README]
(no README description provided)

[APP_FILE] app.py
from __future__ import annotations
from io import BytesIO
from pathlib import Path
from typing import Any
from fastapi.responses import FileResponse
from fastapi.staticfiles import StaticFiles
from gradio import Server
from PIL import Image, ImageOps, UnidentifiedImageError
from traces.runtime import queue_trace, start_trace_worker, trace_status
from huggingface_hub import hf_hub_download
from llama_cpp import Llama
from llama_cpp.llama_chat_format import MTMDChatHandler
from llama_cpp import Llama, llama_cpp

"""Pakistan Notice Helper: custom frontend with a queued Gradio backend."""

from __future__ import annotations

import argparse
import base64
import ctypes
import gc
import importlib.util
import json
import logging
import os
import re
import sys
import threading
import time
from io import BytesIO
from pathlib import Path
from typing import Any

import spaces
from fastapi.responses import FileResponse
from fastapi.staticfiles import StaticFiles
from gradio import Server
from PIL import Image, ImageOps, UnidentifiedImageError
from traces.runtime import queue_trace, start_trace_worker, trace_status

ROOT = Path(__file__).resolve().parent
STATIC_DIR = ROOT / "static"
DISCLAIMER = (
    "Pakistan Notice Helper does not provide official verification. It checks "
    "common scam signals and gives safe next steps. Always verify through "
    "official websites or helplines before making payments or sharing personal "
    "information."
)
RISK_LABELS = ("Looks normal", "Verify first", "Suspicious", "Likely scam", "Inappropriate")
DEFAULT_MODEL_REPO = "openbmb/MiniCPM-V-4.6-gguf"
DEFAULT_MODEL_FILE = "MiniCPM-V-4_6-Q4_K_M.gguf"
DEFAULT_MMPROJ_FILE = "mmproj-model-f16.gguf"
MAX_IMAGE_BYTES = 8 * 1024 * 1024
MAX_IMAGE_PIXELS = 40_000_000
DEFAULT_IMAGE_MAX_DIMENSION = 1536
DEFAULT_IMAGE_JPEG_QUALITY = 90
REQUIRED_FIELDS = {
    "risk_label",
    "simple_explanation",
    " ...

[Assistant] {"matches":[{"quest":"Llama Champion","confidence":0.98,"evidence":"from llama_cpp import Llama","source":"app_file"},{"quest":"OpenBMB","confidence":0.98,"evidence":"DEFAULT_MODEL_REPO = \"openbmb/MiniCPM-V-4.6-gguf\"","source":"app_file"},{"quest":"Off the Grid","confidence":0.92,"evidence":"from llama_cpp import Llama; MiniCPM-V-4_6 GGUF weights","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Pocket Weather Theater", "sdk": "gradio", "declared_models": ["HuggingFaceTB/SmolLM2-135M-Instruct", "PratikBuilds/pocket-weather-theater-smollm2-135m-lora"], "tags": ["build-small-hackathon", "gradio", "local-inference", "thousand-token-wood", "tiny-models", "transformers"]}

[README]
(no README description provided)

[APP_FILE] app.py
from dataclasses import dataclass
from html import escape
from pathlib import Path
from urllib.parse import quote
from PIL import Image, ImageDraw, ImageFont
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

import base64
import contextlib
import math
import os
import random
import re
import subprocess
import tempfile
import wave
import threading
import zipfile
from dataclasses import dataclass
from html import escape
from pathlib import Path
from urllib.parse import quote

import gradio as gr

try:
    from PIL import Image, ImageDraw, ImageFont
except Exception:  # pragma: no cover - Pillow is installed in runtime requirements
    Image = None
    ImageDraw = None
    ImageFont = None

try:
    import imageio.v3 as iio
except Exception:  # pragma: no cover - optional video renderer
    iio = None

try:
    import imageio_ffmpeg
except Exception:  # pragma: no cover - optional video/audio muxer
    imageio_ffmpeg = None

try:
    import torch
    from transformers import AutoModelForCausalLM, AutoTokenizer
except Exception:  # pragma: no cover - keeps Space shell import-friendly while deps install
    torch = None
    AutoModelForCausalLM = None
    AutoTokenizer = None

try:
    from peft import PeftModel
except Exception:  # pragma: no cover - optional until dependencies finish installing
    PeftModel = None

MODEL_ID = os.getenv("MODEL_ID", "HuggingFaceTB/SmolLM2-135M-Instruct")
TUNED_ADAPTER_ID = os.getenv("TUNED_ADAPTER_ID", "PratikBuilds/pocket-weather-theater-smollm2-135m-lora")
MAX_NEW_TOKENS = int(os.getenv("MAX_NEW_TOKENS", "52"))
POSTER_PATH = Path(__file__).resolve().parent / "assets" / "pocket-weather-poster.png"
MEDIA_DIR = Path(tempfile.gettempdir()) / "pocket_weather_theater_media"
MEDIA_DIR.mkdir(parents=True, exist_ok=True)
SPACE_URL = "https://huggingface.co/spaces/build-small-hackathon/pocket-weather-theate ...

[Assistant] {"matches":[{"quest":"Tiny Titan","confidence":0.97,"evidence":"MODEL_ID HuggingFaceTB/SmolLM2-135M-Instruct (135M)","source":"app_file"},{"quest":"Well-Tuned","confidence":0.96,"evidence":"TUNED_ADAPTER_ID ...smollm2-135m-lora; from peft import PeftModel","source":"app_file"},{"quest":"Off the Grid","confidence":0.93,"evidence":"local transformers load, no openai/anthropic/gemini imports","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Road B: The Other Screen", "sdk": "gradio", "declared_models": ["unsloth/Qwen3.5-9B-GGUF"], "tags": ["build-small-hackathon", "custom-frontend", "gguf", "gradio", "gradio-server", "interactive-fiction", "llama-cpp", "modal", "qwen", "small-models"]}

[README]
(no README description provided)

[APP_FILE] app.py
from __future__ import annotations
from functools import lru_cache
from pathlib import Path
from typing import Any, Dict, List, Optional
from gradio import Server  # type: ignore[attr-defined]
from fastapi.responses import HTMLResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from llama_cpp import Llama

"""Road B: The Other Screen - hackathon-ready Gradio Server app.

Custom frontend: index.html
Model runtime: Qwen GGUF through llama.cpp via llama-cpp-python
No mock fallback: if the model/runtime cannot load, the app returns a visible error.
"""

from __future__ import annotations

import ctypes
import datetime as dt
import glob
import html
import json
import os
import re
import requests
import site
import threading
import uuid
from functools import lru_cache
from pathlib import Path
from typing import Any, Dict, List, Optional

try:
    import gradio as gr
except Exception:  # pragma: no cover
    gr = None  # type: ignore[assignment]

try:
    from gradio import Server  # type: ignore[attr-defined]
except Exception:  # pragma: no cover
    Server = None  # type: ignore[assignment]

try:
    from fastapi.responses import HTMLResponse, JSONResponse
    from fastapi.staticfiles import StaticFiles
except Exception:  # pragma: no cover
    HTMLResponse = None  # type: ignore[assignment]
    JSONResponse = None  # type: ignore[assignment]
    StaticFiles = None  # type: ignore[assignment]

# -----------------------------------------------------------------------------
# CUDA library preparation for pip-installed NVIDIA runtime packages
# -----------------------------------------------------------------------------

def _candidate_site_dirs() -> List[Path]:
    dirs: List[Path] = []
    try:
        dirs.extend(Path(p) for p in site.getsitepackages())
    except Exception:
        pass
    try:
        dirs.append(Path(site.getusersitepackages()))
    e ...

[Assistant] {"matches":[{"quest":"Llama Champion","confidence":0.97,"evidence":"from llama_cpp import Llama","source":"app_file"},{"quest":"Off-Brand","confidence":0.9,"evidence":"from gradio import Server; custom frontend: index.html","source":"app_file"},{"quest":"Off the Grid","confidence":0.85,"evidence":"Qwen GGUF through llama.cpp via llama-cpp-python","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Voice Sales Logger", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
(no README description provided)

[APP_FILE] app.py
from dotenv import load_dotenv
from gradio_wizardcapture import WizardCapture
from nemo.collections.asr.models.rnnt_bpe_models_prompt import RNNTPromptTranscribeConfig
from transformers import AutoModelForCausalLM, AutoTokenizer

import os

ON_SPACE = bool(os.environ.get("SPACE_ID"))

import re
import json
import math
import base64
import sqlite3
import logging
import datetime
import subprocess
import tempfile
import pandas as pd
import gradio as gr
from dotenv import load_dotenv
import sys
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "wizardcapture", "backend"))
from gradio_wizardcapture import WizardCapture

if not ON_SPACE:
    import modal

load_dotenv()

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
log = logging.getLogger(__name__)

# ---------------------------------------------------------------------------
# Config
# ---------------------------------------------------------------------------

DB_PATH = "sales.db"

CATALOG = {
    "apple":      {"price": 0.50, "unit": "count", "emoji": "🍎"},
    "carrot":     {"price": 0.75, "unit": "count", "emoji": "🥕"},
    "strawberry": {"price": 1.20, "unit": "count", "emoji": "🍓"},
    "banana":     {"price": 0.30, "unit": "count", "emoji": "🍌"},
    "orange":     {"price": 0.60, "unit": "count", "emoji": "🍊"},
    "tomato":     {"price": 0.80, "unit": "count", "emoji": "🍅"},
    "potato":     {"price": 0.40, "unit": "count", "emoji": "🥔"},
    "onion":      {"price": 0.35, "unit": "count", "emoji": "🧅"},
}

LANGUAGE_CODES = {
    "English":    "en-US",
    "Spanish":    "es-US",
    "Vietnamese": "vi-VN",
}

EMPTY_ITEMS_DF = pd.DataFrame(columns=["Item", "Qty", "Unit", "Price", "Total"])

# ---------------------------------------------------------------------------
# Space inference (ON_SPACE=True only) — persistent CPU workers
# ---------------- ...

[Assistant] {"matches":[{"quest":"Modal","confidence":0.8,"evidence":"if not ON_SPACE: import modal","source":"app_file"},{"quest":"Off the Grid","confidence":0.58,"evidence":"transformers AutoModelForCausalLM + nemo.collections.asr; no cloud API","source":"app_file"},{"quest":"Off-Brand","confidence":0.45,"evidence":"from gradio_wizardcapture import WizardCapture (vendored component)","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "CodeFlow", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
(no README description provided)

[APP_FILE] app.py
from huggingface_hub import hf_hub_download
from llama_cpp import Llama
from gradio import Server
from fastapi.responses import HTMLResponse # serve the custom frontend from a route
from typing import Any, cast # to resolve PyLance freaking out over llama-cpp-python in the generate_flowchart function
from textwrap import dedent

"""
3. Graph. Capture the resulting mermaid string and visualize it

To do
- create the custom gradio look
- explore making it look better
- get a better model — Qwen 30b coder
- use zerogpu

"""
from huggingface_hub import hf_hub_download
from llama_cpp import Llama
import gradio as gr
from gradio import Server
from fastapi.responses import HTMLResponse # serve the custom frontend from a route
from typing import Any, cast # to resolve PyLance freaking out over llama-cpp-python in the generate_flowchart function
from textwrap import dedent
import re # remove thinking tag from response

    out = []
    for line in text.split('\n'):
        line = re.sub(r'(?<=\w)\[(.*?)\]' + END, lambda m: '["' + esc(m.group(1)) + '"]', line)
        line = re.sub(r'(?<=\w)\{(.*?)\}' + END, lambda m: '{"' + esc(m.group(1)) + '"}', line)
        out.append(line)
    return '\n'.join(out)

@app.api(name="generate_flowchart")
def generate_flowchart(src_code: str) -> str:
    # check if src_code is empty
    if not src_code.strip(): return ""

    # Set system prompt
    system_prompt = dedent("""
    ## Role/Persona
    You are a senior staff software architect and compiler engineer specializing in visual control-flow mapping. Your philosophy is pure utility: you translate raw execution logic into highly accurate, scannable, structural diagrams without any conversational filler, meta-commentary, or stylistic fluff.

    ## Context/Objective
    The user will provide source code files or logic snippets. Your sole objective is to parse the syntax and output a co ...

[Assistant] {"matches":[{"quest":"Llama Champion","confidence":0.97,"evidence":"from llama_cpp import Llama","source":"app_file"},{"quest":"Off the Grid","confidence":0.88,"evidence":"llama_cpp Llama + hf_hub_download GGUF; no openai/anthropic clients","source":"app_file"},{"quest":"Off-Brand","confidence":0.7,"evidence":"HTMLResponse serve the custom frontend from a route","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "rarebirds", "sdk": "gradio", "declared_models": ["google/gemma-3-27b-it"], "tags": ["ads-b", "aircraft", "gemma", "gradio"]}

[README]
(no README description provided)

[APP_FILE] app.py
from __future__ import annotations
from scripts.gradio_rarity_tester import (

#!/usr/bin/env python3
from __future__ import annotations

from scripts.gradio_rarity_tester import (
    APP_CSS,
    APP_THEME,
    DEFAULT_ADAPTER_DIR,
    DEFAULT_LOAD_IN_4BIT,
    DEFAULT_MAX_SEQ_LENGTH,
    DEFAULT_MODEL_ID,
    build_app,
)

app = build_app(
    model_id=DEFAULT_MODEL_ID,
    adapter_dir=DEFAULT_ADAPTER_DIR,
    load_in_4bit=DEFAULT_LOAD_IN_4BIT,
    max_seq_length=DEFAULT_MAX_SEQ_LENGTH,
)

if __name__ == "__main__":
    app.launch(theme=APP_THEME, css=APP_CSS)

[Assistant] {"matches":[{"quest":"Well-Tuned","confidence":0.82,"evidence":"adapter_dir=DEFAULT_ADAPTER_DIR","source":"app_file"},{"quest":"Off-Brand","confidence":0.78,"evidence":"app.launch(theme=APP_THEME, css=APP_CSS)","source":"app_file"},{"quest":"Off the Grid","confidence":0.6,"evidence":"build_app load_in_4bit, no cloud imports","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Advent Of A World Of Flowering Trees", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
(no README description provided)

[APP_FILE] app.py
from huggingface_hub import hf_hub_download
from llama_cpp import Llama

import gradio as gr
import spaces
from huggingface_hub import hf_hub_download
import os
import ctypes

MODEL_REPO_ID = "CohereLabs/tiny-aya-global-GGUF"
MODEL_FILENAME = "tiny-aya-global-q4_k_m.gguf"

model_path = hf_hub_download(
    repo_id=MODEL_REPO_ID,
    filename=MODEL_FILENAME,
)

_llm = None

# try:
#     import nvidia.cuda_runtime
#     import nvidia.cublas
#     cudart = os.path.join(os.path.dirname(nvidia.cuda_runtime.__file__), "lib", "libcudart.so.12")
#     cublas = os.path.join(os.path.dirname(nvidia.cublas.__file__), "lib", "libcublas.so.12")
#     ctypes.CDLL(cudart, mode=ctypes.RTLD_GLOBAL)
#     ctypes.CDLL(cublas, mode=ctypes.RTLD_GLOBAL)
# except Exception:
#     pass

def get_llm():
    global _llm
    if _llm is None:
        from llama_cpp import Llama

        _llm = Llama(
            model_path=model_path,
            n_gpu_layers=-1,
            n_ctx=1024,
            flash_attn=True,
            verbose=False,
        )
    return _llm

@spaces.GPU(duration=120)
def run_inference(prompt: str) -> str:
    prompt = prompt.strip()
    if not prompt:
        return "Enter a prompt to generate a response."

    try:
        llm = get_llm()
    except Exception as exc:
        return f"llama-cpp initialization failed: {exc}"

    response = llm.create_chat_completion(
        messages=[{"role": "user", "content": prompt}],
        max_tokens=512,
        temperature=0.7,
    )
    return response["choices"][0]["message"]["content"].strip()

with gr.Blocks(title="Advent Of A World Of Flowering Trees") as demo:
    gr.Markdown("# Advent Of A World Of Flowering Trees")
    gr.Markdown("Tiny Aya GGUF demo running with `llama-cpp-python`.")

    prompt = gr.Textbox(
        label="Prompt",
        lines=6,
        placeholder="Ask something...",
    )
    output = gr.Textbo ...

[Assistant] {"matches":[{"quest":"Llama Champion","confidence":0.98,"evidence":"from llama_cpp import Llama; loads .gguf via Llama(","source":"app_file"},{"quest":"Off the Grid","confidence":0.9,"evidence":"runs GGUF locally via llama_cpp, no cloud API client","source":"app_file"},{"quest":"Tiny Titan","confidence":0.85,"evidence":"MODEL_REPO_ID = \"CohereLabs/tiny-aya-global-GGUF\"","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Mini Fam", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
(no README description provided)

[APP_FILE] app.py
from minifam import agent, config

"""MiniFam — a local AI family assistant. Gradio entry point (Hugging Face Space).

Run locally:   source .venv/bin/activate && python app.py
Then open the printed http://127.0.0.1:7860 URL.
"""

import gradio as gr

from minifam import agent, config

def respond(user_msg, display_history, raw_messages, member):
    """Handle one chat submission."""
    user_msg = (user_msg or "").strip()
    if not user_msg:
        return display_history, raw_messages, ""

    raw_messages = raw_messages + [{"role": "user", "content": user_msg}]
    try:
        reply, raw_messages = agent.run_agent(raw_messages, member)
    except Exception as e:
        reply = (
            f"⚠ Could not reach the model ({e}).\n\n"
            "Is Ollama running and is the model pulled? Try: `ollama run qwen3:30b`"
        )

    display_history = display_history + [
        {"role": "user", "content": user_msg},
        {"role": "assistant", "content": reply},
    ]
    return display_history, raw_messages, ""

def switch_member(_member):
    """Start a fresh conversation when the active member changes."""
    return [], []

with gr.Blocks(title="MiniFam") as demo:
    gr.Markdown(
        "# 🏡 MiniFam\n"
        "Your family's assistant — runs entirely on your own computer."
    )

    member = gr.Dropdown(
        choices=config.MEMBERS,
        value=config.MEMBERS[0],
        label="Who's talking?",
    )

    chatbot = gr.Chatbot(height=460, label="MiniFam")
    raw_state = gr.State([])  # full model conversation (incl. tool calls)

    msg = gr.Textbox(
        placeholder="e.g. Remind me to buy milk tomorrow  ·  What are my notes?",
        label="Message",
        autofocus=True,
    )

    msg.submit(
        respond,
        inputs=[msg, chatbot, raw_state, member],
        outputs=[chatbot, raw_state, msg],
    )
    member.change(switch_member, ...

[Assistant] {"matches":[{"quest":"Off the Grid","confidence":0.88,"evidence":"runs entirely on your own computer; ollama run qwen3:30b","source":"app_file"},{"quest":"Best Agent","confidence":0.78,"evidence":"agent.run_agent; full model conversation (incl. tool calls)","source":"app_file"},{"quest":"Backyard AI","confidence":0.7,"evidence":"a local AI family assistant; Your family's assistant","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "The Kintsugi Garden", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
(no README description provided)

[APP_FILE] app.py
from PIL import Image, ImageDraw, ImageFont

"""
The Kintsugi Garden
A symbolic mirror for dreams, journals, and inner transitions.

A small-model symbolic reflection app built for the Build Small Hackathon.

This is NOT therapy, diagnosis, prediction, fortune-telling, or advice.
It is a symbolic reflection tool.

The design philosophy is "small model, strong scaffolding": rather than
relying on the LLM alone, the app surrounds a lightweight instruction model
(microsoft/Phi-4-mini-instruct) with deterministic Python:

  * a curated symbolic lexicon
  * keyword / symbol extraction with aliases and simple plurals
  * a session-local "Soul Map" memory
  * prompt compression (only the current entry + extracted symbols are sent)
  * structured, parsed output
  * deterministic mandala generation with PIL (no image model required)

Author: Build Small Hackathon submission
"""

import os
import re
import sys
import json
import math
import datetime
import traceback

import gradio as gr
import pandas as pd
from PIL import Image, ImageDraw, ImageFont

# `spaces` is only available on HF Spaces with zero-* hardware tiers. Guard
# the import so local development (Mac, Linux, etc.) doesn't hard-fail.
# Outside HF Spaces, @spaces.GPU becomes a no-op passthrough decorator.
try:
    import spaces
except Exception:  # pragma: no cover - local dev environments
    class _SpacesStub:
        def GPU(self, *args, **kwargs):
            def decorator(fn):
                return fn
            return decorator
    spaces = _SpacesStub()

# Torch / transformers are imported lazily inside load_model() so that the
# Gradio interface can still render even if the heavy stack has trouble
# loading. We import torch eagerly because we need its dtype constants, but
# guard it so the app never hard-crashes at import time.
try:
    import torch
except Exception:  # pragma: no cover - extremely defensiv ...

[Assistant] {"matches":[{"quest":"Tiny Titan","confidence":0.95,"evidence":"lightweight instruction model (microsoft/Phi-4-mini-instruct)","source":"app_file"},{"quest":"Off the Grid","confidence":0.78,"evidence":"transformers imported lazily inside load_model(); no cloud API clients","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Lolaby", "sdk": "gradio", "declared_models": ["build-small-hackathon/lolaby-llama-3b", "openbmb/MiniCPM-V-4_6", "hexgrad/Kokoro-82M"], "tags": ["agentic", "backyard-ai", "build-small-hackathon", "children", "fine-tuned", "gradio", "llama-cpp", "lullaby", "on-device", "small-models", "text-to-audio"]}

[README]
(no README description provided)

[APP_FILE] app.py
from pathlib import Path
from llama_cpp import Llama
from synths.guitar import GuitarSynth, ACOUSTIC_PRESET, SR
from synths.piano import PianoSynth
from synths.harp import HarpSynth
from synths.xylophone import XylophoneSynth
from synths.ocarina import WhistleSynth
from synths.musicbox import MusicBoxSynth
from synths.voice import speak_lyrics, SR_TARGET
from utils import trace as lola_trace
from utils.safety import screen_inputs
from synths.voice import _load_kokoro

"""
Lullaby Llama — personalized bedtime music, generated on-device.

Three-layer audio:
  1. Rhythm layer  — user-selected instrument plays the chord progression.
  2. Melody layer  — user-selected instrument plays a melodic line over the chords.
  3. Voice layer   — Kokoro reads the lyrics, soft preset, slow pacing.

The user picks both layers with image buttons in the UI.

Aesthetic: children's drawing — crayon textures, wobbly hand-drawn borders.
"""

import base64
import glob
import os
import random
import re
import tempfile
import time
import uuid
from pathlib import Path

import gradio as gr
import numpy as np
import soundfile as sf
from llama_cpp import Llama

from synths.guitar import GuitarSynth, ACOUSTIC_PRESET, SR
from synths.piano import PianoSynth
from synths.harp import HarpSynth
from synths.xylophone import XylophoneSynth
from synths.ocarina import WhistleSynth
from synths.musicbox import MusicBoxSynth
from synths.voice import speak_lyrics, SR_TARGET
from utils import trace as lola_trace
try:
    from utils.safety import screen_inputs
except ImportError:
    # safety.py absent — degrade to a no-op screen rather than crash.
    def screen_inputs(loves, fears):
        return (True, "", [])

# Vision module (drawing → "loves" phrase). Falls back to stroke analysis
# internally if MiniCPM-V can't load, so the drawing input always produces
# SOMETHING for the lullaby to be about.
try:
    imp ...

[Assistant] {"matches":[{"quest":"Llama Champion","confidence":0.97,"evidence":"from llama_cpp import Llama","source":"app_file"},{"quest":"OpenBMB","confidence":0.9,"evidence":"MiniCPM-V can't load (openbmb/MiniCPM-V-4_6)","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Gitopadesh", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
(no README description provided)

[APP_FILE] app.py
from huggingface_hub import InferenceClient
from bhagavad_gita import format_verse_for_prompt, GITA_CHAPTERS
from PIL import Image, ImageDraw, ImageFont
from io import BytesIO
from sentence_transformers import SentenceTransformer

import gradio as gr
from huggingface_hub import InferenceClient
import os
import json
import numpy as np
from bhagavad_gita import format_verse_for_prompt, GITA_CHAPTERS
from PIL import Image, ImageDraw, ImageFont
import math
import base64
from io import BytesIO

# Browser-native TTS via JavaScript - no server delay, streams with text
HAS_VOICE = True  # Always true - voice handled client-side

# ════════════════════════════════════════════════════════════════
# MULTILINGUAL SUPPORT
# ════════════════════════════════════════════════════════════════

TRANSLATIONS = {
    "en": {
        "title": "GITOPADESH",
        "subtitle": "Speak your struggle. Receive the wisdom of eternity.",
        "dilemma_label": "Your Dilemma, O Seeker",
        "dilemma_placeholder": "O Krishna, I am troubled by...",
        "choose_struggle": "Or choose a common struggle:",
        "seek_button": "✦  SEEK KRISHNA'S GUIDANCE  ✦",
        "krishna_speaks": "Krishna Speaks",
        "emotion_label": "Arjuna's Emotion:",
        "chapter_map": "Battlefield Map — Chapters Invoked",
        "journey": "Your Battlefield Journey",
        "shloka_card": "📿 Your Shloka Card — Download & Share",
        "language": "Language"
    },
    "hi": {
        "title": "गीतोपदेश",
        "subtitle": "अपना संघर्ष बताएं। शाश्वत ज्ञान प्राप्त करें।",
        "dilemma_label": "आपकी समस्या, हे सन्निहित",
        "dilemma_placeholder": "हे कृष्ण, मैं परेशान हूँ...",
        "choose_struggle": "या एक सामान्य संघर्ष चुनें:",
        "seek_button": "✦  कृष्ण का मार्गदर्शन प्राप्त करें  ✦",
        "krishna_speaks": "कृष्ण बोलते हैं",
        "emotion_label": "अर्जुन की भावना:", ...

[Assistant] {"matches":[{"quest":"Sharing is Caring","confidence":0.8,"evidence":"Your Shloka Card, Download and Share","source":"app_file"},{"quest":"Off-Brand","confidence":0.6,"evidence":"multilingual TRANSLATIONS UI, Battlefield Map, PIL shloka card","source":"app_file"}]}


[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "ContextForge", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
(no README description provided)

[APP_FILE] app.py
from __future__ import annotations
from dataclasses import dataclass
from functools import lru_cache
from typing import Any, Callable
from transformers import AutoModelForCausalLM, AutoTokenizer

from __future__ import annotations

import json
import os
import re
import time
from dataclasses import dataclass
from functools import lru_cache
from typing import Any, Callable

APP_TITLE = "ContextForge"
APP_SUBTITLE = "From fuzzy brief to build-ready agent blueprint."
DEFAULT_MODEL_ID = "Qwen/Qwen2.5-0.5B-Instruct"
DEFAULT_MID_MODEL_ID = "RthItalia/nano_compact_3b_qkvfp16"
DEFAULT_HIGH_MODEL_ID = "Qwen/Qwen3-32B"
REQUIRED_PROMPT_TAGS = [
    "ROLE",
    "COGNITIVE_LAYERS",
    "KAHNEMAN_SYSTEM2",
    "PARETO_80_20",
    "VITAL_SPOT",
    "REASONING_PROTOCOL",
    "AGENTIC_LOOP",
    "ACTION",
    "FORMAT_AND_TARGET",
    "QA_CHECKS",
]
TOPOLOGIES = ["Auto", "Single Prompt", "Cascade", "Context Pack", "Agent Workflow"]
REASONING_LAYERS = [
    "CRAFT",
    "Kahneman System 2",
    "Pareto 80/20",
    "Agentic Loop",
    "Tree of Thought controlled",
    "Private CoT",
    "Self-Correction",
    "Sentinel Recovery",
]
STAGE_NAMES = [
    "intake_analysis",
    "topology_decision",
    "vital_structure",
    "reasoning_architecture",
    "prompt_pack_generation",
    "qa_repair",
    "final_assembly",
]
STAGE_TOKEN_BUDGETS = {
    "intake_analysis": 180,
    "topology_decision": 140,
    "vital_structure": 180,
    "reasoning_architecture": 240,
    "prompt_pack_generation": 520,
    "qa_repair": 260,
    "final_assembly": 260,
}

def parse_bool_env(name: str, default: bool = False) -> bool:
    raw = os.getenv(name)
    if raw is None:
        return default
    return raw.strip().lower() in {"1", "true", "yes", "on"}

def parse_int_env(name: str, default: int, minimum: int, maximum: int) -> int:
    try:
        value = int(os.getenv(name, str(default)))
    except Valu ...

[Assistant] {"matches":[{"quest":"Off the Grid","confidence":0.85,"evidence":"from transformers import AutoModelForCausalLM, AutoTokenizer; no cloud imports","source":"app_file"},{"quest":"Tiny Titan","confidence":0.85,"evidence":"DEFAULT_MODEL_ID = \"Qwen/Qwen2.5-0.5B-Instruct\"","source":"app_file"}]}


Backyard AI
Llama Champion
Modal
Off the Grid
Off-Brand
Well-Tuned

[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Kasualdad LFED", "sdk": "gradio", "declared_models": [], "tags": ["duckdb", "education", "gguf", "gradio", "llama-cpp", "local-first", "text-to-sql"]}

[README]
# 🏫 Kasualdad LFED **Local-First Education Data** — ask questions about your district in plain English, get answers instantly. All inference runs on your machine. No data ever leaves. > 🏆 Built for the **HF Build Small Hackathon** (Chapter One: Backyard AI) --- ## 🏅 Hackathon Badges | Badge | Status | How | |---|---|---| | **Off the Grid** | ✅ | All inference via llama.cpp + local GGUF. No API calls. No cloud. | | **Well-Tuned** | ✅ | Fine-tuned Qwen2.5-Coder-7B on 1,200+ synthetic NL→SQL pairs via Unsloth QLoRA on Modal A10G. | | **Llama Champion** | ✅ | llama.cpp as the sole inference backend. Q4_K_M quantization. Streaming token generation. | | **Off-Brand** | ✅ | Custom design system (Linear/Vercel inspired), WCAG AA, Inter + JetBrains Mono, documented below. | --- ## 🎯 What It Does A school district admin (principal, superintendent, department head) types a question: > *"What percentage of students at Lincoln Elementary were chronically absent in 2023-2024?"* Kasualdad LFED: 1. Sends the question + schema context to a local LLM (llama.cpp) 2. Streams the generated SQL back in real-time 3. Validates the SQL against the actual schema (column names, safety) 4. Executes it on an in-memory DuckDB database 5. Returns the results as a table All local. No API keys. No data exfiltration. --- ## 🏗 Architecture ```mermaid flowchart TD U[👤 School Admin] -->|natural language| UI[Gradio UI] UI -->|question + schema| LLM[model_inference.py] LLM -->|llama.cpp| GGUF[Qwen2.5-Coder-7B<br/> ...

[APP_FILE] app.py
(no app file available)

[Assistant] {"matches":[{"quest":"Off the Grid","confidence":0.95,"evidence":"All inference via llama.cpp + local GGUF. No API calls. No cloud.","source":"readme"},{"quest":"Llama Champion","confidence":0.95,"evidence":"llama.cpp as the sole inference backend. Q4_K_M quantization.","source":"readme"},{"quest":"Well-Tuned","confidence":0.93,"evidence":"Fine-tuned Qwen2.5-Coder-7B on 1,200+ synthetic NL→SQL pairs via Unsloth QLoRA","source":"readme"},{"quest":"Backyard AI","confidence":0.85,"evidence":"school district admin (principal, superintendent, department head) types a question","source":"readme"},{"quest":"Off-Brand","confidence":0.75,"evidence":"Custom design system (Linear/Vercel inspired), WCAG AA, Inter + JetBrains Mono","source":"readme"},{"quest":"Modal","confidence":0.7,"evidence":"Fine-tuned ... via Unsloth QLoRA on Modal A10G","source":"readme"}]}


Field Notes
Modal
Nemotron
OpenBMB
Thousand Token Wood
Well-Tuned

[System] You classify hackathon projects against fixed quest dimensions. Return exactly one strict JSON object and nothing else. The first character must be { and the last character must be }. Each match needs quest, confidence, evidence, and source (readme or app_file). Never emit markdown, prose, a top-level array, extra keys, or an unknown or rephrased quest name.

[User]
Classify this hackathon project against the quest dimensions below.
Read the two evidence segments (README and APP_FILE) and judge each quest only from them.

Quests (copy the id on the left verbatim):
- Off the Grid: Runs the model on-device with no remote inference call: weights load locally and inference happens in-process, not over a hosted API. Signals: AWARD on a local in-process load: from_pretrained / pipeline / llama_cpp / diffusers / vLLM / ONNX, GGUF weights, @spaces.GPU. DISQUALIFY (do NOT award) on ANY remote inference call, even via huggingface_hub: InferenceClient, HF Inference API/Endpoints, gradio_client to a remote Space, replicate/together/openrouter/fal/groq, a *.modal.run or other HTTP inference endpoint, or openai/anthropic/gemini/cohere clients. A remote call disqualifies regardless of which model it names.
- Well-Tuned: Uses or publishes a fine-tuned or LoRA-adapted model rather than only stock checkpoints. Signals: LoRA/PEFT adapter, fine-tuned model repo, training script, words like fine-tune, adapter, SFT, distilled.
- Off-Brand: Ships a custom interface beyond default Gradio styling, with a memorable look or voice. Signals: custom CSS/HTML/JS, gr.HTML, gr.Blocks theme/css=, gr.Server, custom components, bespoke theming.
- Llama Champion: Runs a model through the llama.cpp runtime. Signals: llama-cpp-python, from llama_cpp import Llama, GGUF file, llama.cpp, Llama( constructor.
- Sharing is Caring: Produces an output people can save, post, or compare, or publishes an agent trace to the Hub. Signals: download/export button, gr.File/gr.DownloadButton, save PNG/PDF/JSON, push_to_hub of a trace or dataset.
- Field Notes: Documents the build itself with notes, a write-up, or a blog/report link. Signals: README has a substantial build write-up, devlog, lessons learned, or a blog/report/Notion link.
- Backyard AI: Solves a concrete real-world problem for a specific, named person or persona. Signals: README frames a real user and task (caregiving, a relative, a job, a household chore), practical utility.
- Thousand Token Wood: A delightful, playful, or artistic experience that would not exist without AI. Signals: story/game/art/whimsy framing, generative characters or worlds, playful tone, creative novelty.
- OpenBMB: Uses a model published by OpenBMB (the openbmb org), such as the MiniCPM family. Signals: The model id org prefix must be exactly openbmb/ (openbmb/MiniCPM*, OpenCPM). A model from any other org is NOT OpenBMB: openai/gpt-oss, Qwen/..., meta-llama/..., google/..., nvidia/..., microsoft/..., mistralai/... do NOT count just because a model id is present.
- Nemotron: Uses an NVIDIA Nemotron model (Nemotron LLM, Parakeet, Nemotron-Speech, Canary). Signals: model repo nvidia/...nemotron..., Parakeet, nemotron-speech, Canary ASR.
- Modal: Uses Modal for training, inference, or background compute. Signals: import modal, modal.App, @app.function, Modal endpoint/volume, README cites Modal compute.
- Tiny Titan: Runs on a genuinely small model of about four billion parameters or fewer. Signals: AWARD when the model name says <=4B: 0.5B/1B/1.5B/2B/3B/4B or tiny/small/nano/mini (Qwen2.5-1.5B, MiniCPM5-1B, gemma-2b). Do NOT award for 7B/8B/12B/13B/20B/27B/35B+ models (e.g. gpt-oss-20b, Qwen2.5-7B); a version number like V-4.6 is not a parameter count.
- Best Agent: An agentic build: tool use, function calling, planning, or an autonomous multi-step loop. Signals: tool/function calling, an agent/planner loop, multiple orchestrated tools, ReAct, multi-step reasoning over tools.

Rules:
- Include a quest only when a segment gives clear, specific evidence.
- quest must be one id from the list above, copied exactly. Never invent or rephrase a quest name.
- confidence is a number between 0 and 1.
- evidence is a 3-to-12 word quote or tight paraphrase taken from the segment you cite.
- source is "readme" when the evidence is in the README segment, "app_file" when it is in the APP_FILE segment.
- At most one match per quest. Sort matches by confidence, highest first.
- If no quest has clear evidence, return an empty matches list.
- Output exactly one JSON object: {"matches":[{"quest":"...","confidence":0.0,"evidence":"...","source":"readme"}]}.
- No markdown, no code fences, no commentary, no extra keys.

METADATA: {"title": "Thousand Token Wood", "sdk": "gradio", "declared_models": [], "tags": ["gradio", "region:us"]}

[README]
# 🍄 Thousand Token Wood A small-model **finance drama** for the [Build Small Hackathon](https://huggingface.co/build-small-hackathon). Five woodland creatures, each driven by a *different lab's* small model, trade goods for pebbles, gossip, scheme, and panic. You are the **Patron of the Wood**, a shadow financier: you lend, whisper tips, short the market, bribe, and broker alliances, while a magistrate watches for cheats. The chart is the scoreboard; the story is the people. ## Read more - 📓 **Field notes**: [Hugging Face article](https://huggingface.co/blog/build-small/thousand-token-wood-sim) | [Medium](https://medium.com/@LesterLeong/thousand-token-wood-emergent-market-drama-from-3-billion-parameter-agents-22545d5982bf) - 🧠 **Fine-tuned model** (one of the five minds): [AdmiralTaco/ttw-trader-0.5b](https://huggingface.co/AdmiralTaco/ttw-trader-0.5b) - 📡 **Open agent traces** on the Hub: [dataset](https://huggingface.co/datasets/build-small-hackathon/thousand-token-wood-traces) ## Five labs, five minds Every creature thinks with a different small model, so the council is a live argument between four labs, all under the 32B cap and served with vLLM on **Modal**: | Creature | Model | Lab | |---|---|---| | Oona (owl) | gpt-oss-20b | OpenAI | | Bramble (squirrel) | MiniCPM3-4B | OpenBMB | | Fenn (fox) | Nemotron-Mini-4B | NVIDIA | | Mossback (tortoise) + Pip (mouse) | ttw-trader-0.5b (fine-tuned) | ours | The 0.5B was distilled from cleaned traces of a 3B teacher (self-buy mist ...

[APP_FILE] app.py
(no app file available)

[Assistant] {"matches":[{"quest":"Thousand Token Wood","confidence":0.99,"evidence":"Five woodland creatures... trade goods for pebbles, gossip, scheme, and panic","source":"readme"},{"quest":"Well-Tuned","confidence":0.97,"evidence":"ttw-trader-0.5b (fine-tuned)... distilled from a 3B teacher","source":"readme"},{"quest":"OpenBMB","confidence":0.96,"evidence":"Bramble (squirrel) | MiniCPM3-4B | OpenBMB","source":"readme"},{"quest":"Nemotron","confidence":0.96,"evidence":"Fenn (fox) | Nemotron-Mini-4B | NVIDIA","source":"readme"},{"quest":"Modal","confidence":0.95,"evidence":"served with vLLM on Modal; modal deploy serve.py","source":"readme"},{"quest":"Field Notes","confidence":0.9,"evidence":"Field notes: Hugging Face article | Medium","source":"readme"}]}