CraftPilot: multi-agent craft business assistant

.env.example

@@ -0,0 +1,8 @@
+# Vision model (MiniCPM-V 2.6 GGUF)
+VISION_REPO=openbmb/MiniCPM-V-2_6-gguf
+VISION_MODEL_FILE=ggml-model-Q4_K_M.gguf
+VISION_FILE=mmproj-model-f16.gguf
+
+# Text model (Qwen2.5-1.5B-Instruct GGUF)
+TEXT_REPO=Qwen/Qwen2.5-1.5B-Instruct-GGUF
+TEXT_FILE=qwen2.5-1.5b-instruct-q4_k_m.gguf

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+examples/crochet.png filter=lfs diff=lfs merge=lfs -text
+examples/embroidery.jpeg filter=lfs diff=lfs merge=lfs -text
+examples/sew_keychain.jpeg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+.env
+*.gguf
+models/
+.venv/
+*.egg-info/
+dist/
+build/
+token.txt
+docs/

README.md

@@ -1,13 +1,54 @@
 ---
-title: Craftpilot
-emoji: ⚡
-colorFrom: indigo
-colorTo: indigo
+title: CraftPilot
+emoji: 🧶
+colorFrom: yellow
+colorTo: red
 sdk: gradio
-sdk_version: 6.17.3
-python_version: '3.13'
+sdk_version: "6.16.0"
 app_file: app.py
+python_version: "3.10"
 pinned: false
+license: mit
+tags:
+  - craft
+  - vision
+  - multi-agent
+  - llama-cpp
+  - hackathon
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CraftPilot — AI-Powered Craft Business Assistant
+
+Upload a photo of your handmade craft. Get a complete marketplace listing with catalog data, product descriptions, social captions, and fair pricing.
+
+**Built for someone I know** — a creative introvert who does crochet, painting, embroidery, and sewing but struggles to write product listings and price her work fairly.
+
+## How it works
+
+1. Upload a craft photo
+2. Select craft type
+3. (Optional) Add notes, material cost, time spent
+4. Click "Analyze My Craft"
+
+The AI runs a multi-agent pipeline:
+- **Vision** — describes your craft item in detail
+- **Cataloger** — extracts structured metadata (category, materials, colors, tags)
+- **Copywriter** — generates product title, descriptions, and Instagram captions
+- **Pricer** — suggests fair pricing based on materials, labor, and market rates
+
+## Technical Details
+
+- **Single model:** MiniCPM-V 2.6 (~8B) via llama.cpp — handles both vision and text
+- **No cloud APIs** — everything runs locally
+- **Agent traces** — full pipeline transparency in the Agent Traces tab
+
+## Badges
+
+- Llama Champion — all inference via llama.cpp
+- Off the Grid — no cloud API calls
+- Sharing is Caring — agent traces published
+- Field Notes — blog post about the build
+
+## Team
+
+- Solo builder

agents/cataloger.py

@@ -0,0 +1,50 @@
+"""Cataloger agent: analyzes craft items and produces structured metadata."""
+
+from jinja2 import Template
+
+from agents.llm import LLMClient
+from agents.models import AgentTrace, CatalogerOutput
+
+SYSTEM_PROMPT = (
+    "You are a craft catalog expert. Analyze handmade craft items and "
+    "produce structured catalog entries.\n\n"
+    "You understand materials, techniques, and categories for: crochet, "
+    "painting, embroidery, sewing, stitching, and other handmade crafts.\n\n"
+    "Always respond with valid JSON."
+)
+
+USER_TEMPLATE = Template(
+    "Analyze this {{ craft_type }} item and create a catalog entry.\n\n"
+    "Image description: {{ image_description }}\n"
+    "{% if user_notes %}Creator's notes: {{ user_notes }}{% endif %}\n\n"
+    "Categorize it with: category (e.g., 'home decor', 'fashion accessory', "
+    "'wall art'), sub_category (e.g., 'coaster', 'scarf', 'portrait'), "
+    "materials used, colors, estimated size, relevant tags for "
+    "searchability, and complexity level (simple/moderate/complex)."
+)
+
+
+async def run(
+    llm: LLMClient,
+    image_description: str,
+    craft_type: str,
+    user_notes: str | None = None,
+) -> tuple[CatalogerOutput, AgentTrace]:
+    prompt = USER_TEMPLATE.render(
+        craft_type=craft_type,
+        image_description=image_description,
+        user_notes=user_notes,
+    )
+    result, duration_ms = await llm.agenerate(
+        system=SYSTEM_PROMPT,
+        prompt=prompt,
+        output_schema=CatalogerOutput,
+    )
+    trace = AgentTrace(
+        agent_name="cataloger",
+        input_text=prompt,
+        output_data=result.model_dump(),
+        duration_ms=duration_ms,
+        model_id=llm.model_id,
+    )
+    return result, trace

agents/copywriter.py

@@ -0,0 +1,58 @@
+"""Copywriter agent: generates product descriptions and social captions."""
+
+from jinja2 import Template
+
+from agents.llm import LLMClient
+from agents.models import AgentTrace, CatalogerOutput, CopywriterOutput
+
+SYSTEM_PROMPT = (
+    "You are a warm, authentic copywriter for handmade crafts. You write "
+    "product descriptions and social media captions that feel personal and "
+    "artisan -- never corporate or salesy.\n\n"
+    "Your tone: warm, genuine, storytelling, inviting. Write as if a real "
+    "craftsperson is sharing their work.\n\n"
+    "Always respond with valid JSON."
+)
+
+USER_TEMPLATE = Template(
+    "Write marketing copy for this {{ craft_type }} item:\n\n"
+    "Category: {{ catalog.category }} / {{ catalog.sub_category }}\n"
+    "Materials: {{ catalog.materials | join(', ') }}\n"
+    "Colors: {{ catalog.colors | join(', ') }}\n"
+    "Size: {{ catalog.estimated_size }}\n"
+    "Complexity: {{ catalog.complexity }}\n"
+    "{% if user_notes %}Creator's notes: {{ user_notes }}{% endif %}\n\n"
+    "Provide:\n"
+    "1. A catchy product title (under 60 characters)\n"
+    "2. A short description (1-2 sentences)\n"
+    "3. A longer description (1 paragraph, warm and personal)\n"
+    "4. Exactly 3 Instagram caption variations (each under 200 characters, "
+    "include relevant hashtags)"
+)
+
+
+async def run(
+    llm: LLMClient,
+    craft_type: str,
+    catalog: CatalogerOutput,
+    user_notes: str | None = None,
+) -> tuple[CopywriterOutput, AgentTrace]:
+    prompt = USER_TEMPLATE.render(
+        craft_type=craft_type,
+        catalog=catalog,
+        user_notes=user_notes,
+    )
+    result, duration_ms = await llm.agenerate(
+        system=SYSTEM_PROMPT,
+        prompt=prompt,
+        output_schema=CopywriterOutput,
+        max_tokens=1024,
+    )
+    trace = AgentTrace(
+        agent_name="copywriter",
+        input_text=prompt,
+        output_data=result.model_dump(),
+        duration_ms=duration_ms,
+        model_id=llm.model_id,
+    )
+    return result, trace

agents/llm.py

@@ -0,0 +1,152 @@
+"""Unified LLM client: uses a single model for both vision and text tasks."""
+
+import asyncio
+import base64
+import io
+import json
+import logging
+import time
+
+from PIL import Image
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+class LLMClient:
+    """Single model client for vision + text via llama.cpp."""
+
+    def __init__(self, model_path: str, projection_path: str):
+        self.model_path = model_path
+        self.projection_path = projection_path
+        self.model_id = model_path.split("/")[-1]
+        self._model = None
+
+    def _ensure_model(self):
+        if self._model is not None:
+            return
+        from llama_cpp import Llama
+        from llama_cpp.llama_chat_format import MiniCPMv26ChatHandler
+
+        logger.info("Loading model: %s", self.model_path)
+        chat_handler = MiniCPMv26ChatHandler(
+            clip_model_path=self.projection_path
+        )
+        self._model = Llama(
+            model_path=self.model_path,
+            chat_handler=chat_handler,
+            n_ctx=2048,
+            n_threads=2,
+            verbose=False,
+        )
+        logger.info("Model loaded")
+
+    def _prepare_image(self, image: Image.Image) -> str:
+        max_dim = 384
+        if max(image.size) > max_dim:
+            ratio = max_dim / max(image.size)
+            new_size = (int(image.width * ratio), int(image.height * ratio))
+            image = image.resize(new_size, Image.LANCZOS)
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        buffer = io.BytesIO()
+        image.save(buffer, format="JPEG", quality=85)
+        b64 = base64.b64encode(buffer.getvalue()).decode()
+        return f"data:image/jpeg;base64,{b64}"
+
+    def _build_example_json(self, schema: type[BaseModel]) -> str:
+        example: dict = {}
+        for name, field in schema.model_fields.items():
+            annotation = field.annotation
+            origin = getattr(annotation, "__origin__", None)
+            if origin is type(None):
+                example[name] = None
+                continue
+            args = getattr(annotation, "__args__", None)
+            if args and type(None) in args:
+                annotation = [a for a in args if a is not type(None)][0]
+            if annotation == str:
+                example[name] = "..."
+            elif annotation == int:
+                example[name] = 0
+            elif annotation == float:
+                example[name] = 0.0
+            elif annotation == bool:
+                example[name] = False
+            elif annotation is list or (
+                hasattr(annotation, "__origin__")
+                and getattr(annotation, "__origin__", None) is list
+            ):
+                example[name] = ["..."]
+            else:
+                example[name] = "..."
+        return json.dumps(example, indent=2)
+
+    def describe_image(self, image: Image.Image, prompt: str) -> tuple[str, int]:
+        """Describe an image. Returns (description, duration_ms)."""
+        self._ensure_model()
+        data_uri = self._prepare_image(image)
+
+        start = time.monotonic()
+        response = self._model.create_chat_completion(
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "image_url", "image_url": {"url": data_uri}},
+                        {"type": "text", "text": prompt},
+                    ],
+                }
+            ],
+            max_tokens=256,
+        )
+        duration_ms = int((time.monotonic() - start) * 1000)
+        content = response["choices"][0]["message"]["content"]
+        return content, duration_ms
+
+    def generate(
+        self,
+        system: str,
+        prompt: str,
+        output_schema: type[BaseModel],
+        max_tokens: int = 512,
+    ) -> tuple[BaseModel, int]:
+        """Generate structured JSON output. Returns (parsed_model, duration_ms)."""
+        self._ensure_model()
+
+        example_json = self._build_example_json(output_schema)
+        json_instruction = (
+            "\n\nRespond ONLY with a valid JSON object. "
+            f"Use exactly these keys:\n{example_json}\n"
+            "Fill in real values. Do not include any text outside the JSON."
+        )
+
+        start = time.monotonic()
+        response = self._model.create_chat_completion(
+            messages=[
+                {"role": "system", "content": system + json_instruction},
+                {"role": "user", "content": prompt},
+            ],
+            max_tokens=max_tokens,
+            response_format={"type": "json_object"},
+        )
+        duration_ms = int((time.monotonic() - start) * 1000)
+
+        content = response["choices"][0]["message"]["content"]
+        return output_schema.model_validate_json(content), duration_ms
+
+    async def adescribe_image(
+        self, image: Image.Image, prompt: str
+    ) -> tuple[str, int]:
+        return await asyncio.to_thread(self.describe_image, image, prompt)
+
+    async def agenerate(
+        self,
+        system: str,
+        prompt: str,
+        output_schema: type[BaseModel],
+        max_tokens: int = 512,
+    ) -> tuple[BaseModel, int]:
+        return await asyncio.to_thread(
+            self.generate, system, prompt, output_schema, max_tokens
+        )

agents/models.py

@@ -0,0 +1,44 @@
+"""Pydantic models for the agent system."""
+
+from pydantic import BaseModel
+
+
+class CatalogerOutput(BaseModel):
+    category: str
+    sub_category: str
+    materials: list[str]
+    colors: list[str]
+    estimated_size: str
+    tags: list[str]
+    complexity: str
+
+
+class CopywriterOutput(BaseModel):
+    title: str
+    short_desc: str
+    long_desc: str
+    captions: list[str]
+
+
+class PricerOutput(BaseModel):
+    suggested_price_min: int
+    suggested_price_max: int
+    reasoning: str
+    cost_breakdown: str | None = None
+
+
+class AgentTrace(BaseModel):
+    agent_name: str
+    input_text: str
+    output_data: dict
+    duration_ms: int
+    model_id: str
+
+
+class PipelineResult(BaseModel):
+    image_description: str
+    catalog: CatalogerOutput | None = None
+    copy_data: CopywriterOutput | None = None
+    pricing: PricerOutput | None = None
+    traces: list[AgentTrace] = []
+    total_duration_ms: int = 0

agents/pipeline.py

@@ -0,0 +1,82 @@
+"""Orchestration pipeline: vision -> cataloger -> (copywriter + pricer)."""
+
+import asyncio
+import logging
+import time
+from collections.abc import Callable
+
+from PIL import Image
+
+from agents import cataloger, copywriter, pricer
+from agents.llm import LLMClient
+from agents.models import AgentTrace, PipelineResult
+
+logger = logging.getLogger(__name__)
+
+VISION_PROMPT = (
+    "Describe this handmade craft item in detail. Include: "
+    "what type of craft it is (crochet, embroidery, painting, sewing, etc.), "
+    "colors used, materials visible, approximate size, style, "
+    "and any notable patterns or techniques. "
+    "Be specific and descriptive."
+)
+
+
+async def run(
+    llm: LLMClient,
+    image: Image.Image,
+    craft_type: str,
+    user_notes: str | None = None,
+    material_cost: float | None = None,
+    time_hours: float | None = None,
+    on_progress: Callable | None = None,
+) -> PipelineResult:
+    """Run the full craft analysis pipeline with a single model."""
+    start = time.monotonic()
+    traces: list[AgentTrace] = []
+
+    # Stage 0: Vision analysis
+    if on_progress:
+        on_progress("Analyzing image...")
+    description, vision_ms = await llm.adescribe_image(image, VISION_PROMPT)
+    traces.append(AgentTrace(
+        agent_name="vision",
+        input_text="[image]",
+        output_data={"description": description},
+        duration_ms=vision_ms,
+        model_id=llm.model_id,
+    ))
+
+    # Stage 1: Cataloger
+    if on_progress:
+        on_progress("Cataloging item...")
+    catalog_result, catalog_trace = await cataloger.run(
+        llm, description, craft_type, user_notes
+    )
+    traces.append(catalog_trace)
+
+    # Stage 2: Copywriter + Pricer (sequential — single model)
+    if on_progress:
+        on_progress("Writing copy...")
+    copy_result, copy_trace = await copywriter.run(
+        llm, craft_type, catalog_result, user_notes
+    )
+    traces.append(copy_trace)
+
+    if on_progress:
+        on_progress("Calculating pricing...")
+    price_result, price_trace = await pricer.run(
+        llm, craft_type, catalog_result, material_cost, time_hours
+    )
+    traces.append(price_trace)
+
+    total_ms = int((time.monotonic() - start) * 1000)
+
+    return PipelineResult(
+        image_description=description,
+        catalog=catalog_result,
+        copy_data=copy_result,
+        pricing=price_result,
+        traces=traces,
+        total_duration_ms=total_ms,
+    )

agents/pricer.py

@@ -0,0 +1,65 @@
+"""Pricer agent: suggests fair pricing for handmade craft items."""
+
+from jinja2 import Template
+
+from agents.llm import LLMClient
+from agents.models import AgentTrace, CatalogerOutput, PricerOutput
+
+SYSTEM_PROMPT = (
+    "You are a pricing expert for handmade crafts sold on Etsy, Instagram, "
+    "and at craft fairs.\n\n"
+    "PRICING RULES (follow strictly):\n"
+    "1. The price MUST ALWAYS be HIGHER than the material cost. Never suggest "
+    "a price below material cost.\n"
+    "2. Labor rate: $15-25/hour for moderate work, $25-40/hour for complex work.\n"
+    "3. Formula: price = material_cost + (hours * labor_rate) + profit_margin.\n"
+    "4. Profit margin: add 20-40% on top.\n"
+    "5. If material_cost + labor exceeds $100, the price must reflect that.\n\n"
+    "Always respond with valid JSON."
+)
+
+USER_TEMPLATE = Template(
+    "Suggest a fair price range for this {{ craft_type }} item:\n\n"
+    "Category: {{ catalog.category }} / {{ catalog.sub_category }}\n"
+    "Materials: {{ catalog.materials | join(', ') }}\n"
+    "Size: {{ catalog.estimated_size }}\n"
+    "Complexity: {{ catalog.complexity }}\n"
+    "{% if material_cost %}Material cost: ${{ material_cost }}{% endif %}\n"
+    "{% if time_hours %}Time spent: {{ time_hours }} hours{% endif %}\n"
+    "{% if material_cost and time_hours %}\n"
+    "MINIMUM price calculation:\n"
+    "- Materials: ${{ material_cost }}\n"
+    "- Labor ({{ time_hours }}h x $20/hr): ${{ (time_hours * 20) | int }}\n"
+    "- Subtotal: ${{ (material_cost + time_hours * 20) | int }}\n"
+    "- The suggested_price_min MUST be at least ${{ (material_cost + time_hours * 20) | int }}\n"
+    "{% endif %}\n"
+    "Provide suggested_price_min, suggested_price_max, reasoning, and cost_breakdown."
+)
+
+
+async def run(
+    llm: LLMClient,
+    craft_type: str,
+    catalog: CatalogerOutput,
+    material_cost: float | None = None,
+    time_hours: float | None = None,
+) -> tuple[PricerOutput, AgentTrace]:
+    prompt = USER_TEMPLATE.render(
+        craft_type=craft_type,
+        catalog=catalog,
+        material_cost=material_cost,
+        time_hours=time_hours,
+    )
+    result, duration_ms = await llm.agenerate(
+        system=SYSTEM_PROMPT,
+        prompt=prompt,
+        output_schema=PricerOutput,
+    )
+    trace = AgentTrace(
+        agent_name="pricer",
+        input_text=prompt,
+        output_data=result.model_dump(),
+        duration_ms=duration_ms,
+        model_id=llm.model_id,
+    )
+    return result, trace

app.py

@@ -0,0 +1,737 @@
+"""CraftPilot - AI-powered craft business assistant.
+
+Upload a photo of your handmade craft, get a complete marketplace listing
+with catalog metadata, product descriptions, social captions, and pricing.
+
+Built for the Build Small Hackathon 2026.
+Multi-agent pipeline: Vision -> Cataloger -> Copywriter + Pricer
+Single model (MiniCPM-V 2.6, ~8B) running locally via llama.cpp.
+No cloud APIs.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import tempfile
+import time
+
+import gradio as gr
+from huggingface_hub import hf_hub_download
+from PIL import Image
+
+from agents import cataloger, copywriter, pricer
+from agents.llm import LLMClient
+from agents.models import AgentTrace, PipelineResult
+from agents.pipeline import VISION_PROMPT
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Set HF token if available (for faster downloads)
+hf_token = os.getenv("HF_TOKEN")
+if hf_token:
+    os.environ["HUGGING_FACE_HUB_TOKEN"] = hf_token
+
+CRAFT_TYPES = [
+    "Crochet",
+    "Embroidery",
+    "Painting",
+    "Sewing",
+    "Knitting",
+    "Other",
+]
+
+MODEL_REPO = os.getenv("MODEL_REPO", "openbmb/MiniCPM-V-2_6-gguf")
+MODEL_FILE = os.getenv("MODEL_FILE", "ggml-model-Q4_K_M.gguf")
+PROJ_FILE = os.getenv("PROJ_FILE", "mmproj-model-f16.gguf")
+
+_llm_client: LLMClient | None = None
+
+CUSTOM_HEAD = '<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=DM+Serif+Display&family=Source+Sans+3:wght@300;400;500;600&display=swap">'
+
+CUSTOM_CSS = """
+:root {
+    --craft-amber: #d4830a;
+    --craft-amber-light: #f5e6cc;
+    --craft-terracotta: #c1644a;
+    --craft-cream: #faf6f0;
+    --craft-warm-gray: #6b5e53;
+    --craft-dark: #3a2e26;
+    --craft-sage: #8a9a7b;
+    --craft-linen: #f0ebe3;
+}
+
+.gradio-container {
+    max-width: 100% !important;
+    background: var(--craft-cream) !important;
+    font-family: 'Source Sans 3', sans-serif !important;
+    padding: 0 2rem !important;
+}
+
+/* Header */
+#craft-header {
+    text-align: center;
+    padding: 2rem 1rem 1.5rem;
+    background: linear-gradient(135deg, var(--craft-amber-light) 0%, var(--craft-linen) 50%, #e8ddd0 100%);
+    border-radius: 16px;
+    margin-bottom: 1.5rem;
+    border: 1px solid rgba(212, 131, 10, 0.15);
+    position: relative;
+    overflow: hidden;
+}
+
+#craft-header::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background: url("data:image/svg+xml,%3Csvg width='60' height='60' viewBox='0 0 60 60' xmlns='http://www.w3.org/2000/svg'%3E%3Cg fill='none' fill-rule='evenodd'%3E%3Cg fill='%23d4830a' fill-opacity='0.04'%3E%3Cpath d='M36 34v-4h-2v4h-4v2h4v4h2v-4h4v-2h-4zm0-30V0h-2v4h-4v2h4v4h2V6h4V4h-4zM6 34v-4H4v4H0v2h4v4h2v-4h4v-2H6zM6 4V0H4v4H0v2h4v4h2V6h4V4H6z'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E");
+    pointer-events: none;
+}
+
+#craft-header h1 {
+    font-family: 'DM Serif Display', serif !important;
+    font-size: 2.8rem !important;
+    color: var(--craft-dark) !important;
+    margin: 0 0 0.25rem !important;
+    letter-spacing: -0.02em;
+}
+
+#craft-header h3 {
+    font-family: 'Source Sans 3', sans-serif !important;
+    color: var(--craft-warm-gray) !important;
+    font-weight: 400 !important;
+    font-size: 1.1rem !important;
+    margin: 0 !important;
+    letter-spacing: 0.03em;
+}
+
+#craft-header p {
+    color: var(--craft-warm-gray) !important;
+    font-size: 0.95rem !important;
+    max-width: 600px;
+    margin: 0.75rem auto 0 !important;
+    line-height: 1.5;
+}
+
+/* Input panel */
+#input-panel {
+    background: white !important;
+    border-radius: 14px !important;
+    border: 1px solid rgba(107, 94, 83, 0.1) !important;
+    padding: 1.25rem !important;
+    box-shadow: 0 2px 12px rgba(58, 46, 38, 0.06) !important;
+}
+
+/* Primary button */
+#analyze-btn {
+    background: linear-gradient(135deg, var(--craft-amber) 0%, var(--craft-terracotta) 100%) !important;
+    border: none !important;
+    color: white !important;
+    font-family: 'Source Sans 3', sans-serif !important;
+    font-weight: 600 !important;
+    font-size: 1.05rem !important;
+    letter-spacing: 0.03em;
+    padding: 0.85rem 2rem !important;
+    border-radius: 10px !important;
+    transition: all 0.25s ease !important;
+    box-shadow: 0 4px 14px rgba(212, 131, 10, 0.3) !important;
+}
+
+#analyze-btn:hover {
+    transform: translateY(-1px) !important;
+    box-shadow: 0 6px 20px rgba(212, 131, 10, 0.4) !important;
+}
+
+/* Export button */
+#export-btn {
+    border: 1px solid var(--craft-amber) !important;
+    color: var(--craft-amber) !important;
+    background: white !important;
+    font-weight: 500 !important;
+    border-radius: 8px !important;
+}
+
+#export-btn:hover {
+    background: var(--craft-amber-light) !important;
+}
+
+/* Output panel */
+#output-panel {
+    background: white !important;
+    border-radius: 14px !important;
+    border: 1px solid rgba(107, 94, 83, 0.1) !important;
+    box-shadow: 0 2px 12px rgba(58, 46, 38, 0.06) !important;
+}
+
+/* Tab styling */
+.tabs > .tab-nav > button {
+    font-family: 'Source Sans 3', sans-serif !important;
+    font-weight: 500 !important;
+    font-size: 0.9rem !important;
+    color: var(--craft-warm-gray) !important;
+    border-bottom: 2px solid transparent !important;
+    padding: 0.6rem 1rem !important;
+}
+
+.tabs > .tab-nav > button.selected {
+    color: var(--craft-amber) !important;
+    border-bottom-color: var(--craft-amber) !important;
+    background: rgba(212, 131, 10, 0.05) !important;
+}
+
+/* Summary card styles */
+.summary-section {
+    padding: 1rem 1.25rem;
+    margin: 0.5rem 0;
+    border-left: 3px solid var(--craft-amber);
+    background: var(--craft-cream);
+    border-radius: 0 8px 8px 0;
+}
+
+/* Status indicator */
+#status-text {
+    text-align: center;
+    padding: 0.75rem;
+}
+
+#status-text p {
+    color: var(--craft-amber) !important;
+    font-weight: 500 !important;
+}
+
+/* Footer */
+#craft-footer {
+    text-align: center;
+    padding: 1.5rem 1rem;
+    margin-top: 1rem;
+}
+
+#craft-footer p {
+    color: var(--craft-warm-gray) !important;
+    font-size: 0.8rem !important;
+    opacity: 0.7;
+}
+
+/* Markdown content styling */
+.prose h2 {
+    font-family: 'DM Serif Display', serif !important;
+    color: var(--craft-dark) !important;
+}
+
+.prose strong {
+    color: var(--craft-dark) !important;
+}
+
+/* Image upload area */
+.image-container {
+    border: 2px dashed rgba(212, 131, 10, 0.25) !important;
+    border-radius: 12px !important;
+    background: var(--craft-cream) !important;
+}
+
+/* Dropdown & textbox refinements */
+.gradio-container input, .gradio-container textarea, .gradio-container select {
+    font-family: 'Source Sans 3', sans-serif !important;
+    border-radius: 8px !important;
+}
+
+label > span {
+    font-family: 'Source Sans 3', sans-serif !important;
+    font-weight: 500 !important;
+    color: var(--craft-warm-gray) !important;
+    font-size: 0.9rem !important;
+}
+"""
+
+
+def download_models() -> tuple[str, str]:
+    """Download GGUF model from HF Hub. Returns (model_path, proj_path)."""
+    logger.info("Downloading models from %s...", MODEL_REPO)
+    model_path = hf_hub_download(repo_id=MODEL_REPO, filename=MODEL_FILE)
+    proj_path = hf_hub_download(repo_id=MODEL_REPO, filename=PROJ_FILE)
+    logger.info("Models downloaded.")
+    return model_path, proj_path
+
+
+def get_client() -> LLMClient:
+    """Lazy-load the unified model client."""
+    global _llm_client
+    if _llm_client is None:
+        model_path, proj_path = download_models()
+        _llm_client = LLMClient(
+            model_path=model_path, projection_path=proj_path
+        )
+    return _llm_client
+
+
+def _format_summary(result: PipelineResult) -> str:
+    """Build a combined summary view of all pipeline results."""
+    parts = []
+
+    # Title & description
+    if result.copy_data:
+        c = result.copy_data
+        parts.append(f"## {c.title}\n")
+        parts.append(f"*{c.short_desc}*\n")
+
+    # Price highlight
+    if result.pricing:
+        p = result.pricing
+        parts.append(
+            f"### Suggested Price: ${p.suggested_price_min}"
+            f" \u2013 ${p.suggested_price_max}\n"
+        )
+
+    parts.append("---\n")
+
+    # Catalog snapshot
+    if result.catalog:
+        cat = result.catalog
+        tags = " ".join(f"`{t}`" for t in cat.tags[:6])
+        parts.append(
+            f"**Category:** {cat.category} / {cat.sub_category}  \n"
+            f"**Materials:** {', '.join(cat.materials)}  \n"
+            f"**Colors:** {', '.join(cat.colors)}  \n"
+            f"**Complexity:** {cat.complexity}\n\n"
+            f"{tags}\n"
+        )
+
+    parts.append("---\n")
+
+    # Full description
+    if result.copy_data:
+        parts.append(f"**Description**\n\n{result.copy_data.long_desc}\n")
+
+    parts.append("---\n")
+
+    # Instagram captions
+    if result.copy_data:
+        parts.append("**Instagram Captions**\n")
+        for i, cap in enumerate(result.copy_data.captions, 1):
+            parts.append(f"{i}. {cap}\n")
+
+    # Pricing reasoning
+    if result.pricing and result.pricing.reasoning:
+        parts.append(f"\n---\n\n**Pricing Rationale**\n\n{result.pricing.reasoning}\n")
+        if result.pricing.cost_breakdown:
+            parts.append(f"\n**Cost Breakdown:** {result.pricing.cost_breakdown}\n")
+
+    # Timing
+    if result.traces:
+        agent_times = " \u2192 ".join(
+            f"{t.agent_name} ({t.duration_ms}ms)" for t in result.traces
+        )
+        parts.append(
+            f"\n---\n\n<small>Pipeline: {agent_times} "
+            f"| Total: {result.total_duration_ms}ms</small>"
+        )
+
+    return "\n".join(parts)
+
+
+def _format_vision(result: PipelineResult) -> str:
+    if not result.image_description:
+        return ""
+    return f"### What the AI sees\n\n{result.image_description}"
+
+
+def _format_catalog(result: PipelineResult) -> str:
+    cat = result.catalog
+    if not cat:
+        return ""
+    tags = " ".join(f"`{t}`" for t in cat.tags)
+    return (
+        f"### Catalog Entry\n\n"
+        f"| Field | Value |\n"
+        f"|-------|-------|\n"
+        f"| **Category** | {cat.category} / {cat.sub_category} |\n"
+        f"| **Materials** | {', '.join(cat.materials)} |\n"
+        f"| **Colors** | {', '.join(cat.colors)} |\n"
+        f"| **Size** | {cat.estimated_size} |\n"
+        f"| **Complexity** | {cat.complexity} |\n\n"
+        f"**Tags:** {tags}"
+    )
+
+
+def _format_copy(result: PipelineResult) -> str:
+    if not result.copy_data:
+        return ""
+    c = result.copy_data
+    copy_text = (
+        f"### {c.title}\n\n"
+        f"**One-liner:** {c.short_desc}\n\n"
+        f"---\n\n"
+        f"**Full Description**\n\n{c.long_desc}\n\n"
+        f"---\n\n"
+        f"**Instagram Captions**\n\n"
+    )
+    for i, cap in enumerate(c.captions, 1):
+        copy_text += f"{i}. {cap}\n\n"
+    return copy_text
+
+
+def _format_pricing(result: PipelineResult) -> str:
+    if not result.pricing:
+        return ""
+    p = result.pricing
+    price_text = (
+        f"### Pricing Recommendation\n\n"
+        f"## ${p.suggested_price_min} \u2013 ${p.suggested_price_max}\n\n"
+        f"---\n\n"
+        f"**Rationale**\n\n{p.reasoning}\n"
+    )
+    if p.cost_breakdown:
+        price_text += f"\n---\n\n**Cost Breakdown**\n\n{p.cost_breakdown}\n"
+    return price_text
+
+
+def _format_traces(result: PipelineResult) -> str:
+    if not result.traces:
+        return ""
+    trace_parts = [
+        f"### Pipeline Trace\n\n"
+        f"**Total time:** {result.total_duration_ms}ms  \n"
+        f"**Agents:** {len(result.traces)} steps\n\n"
+        f"| Step | Agent | Duration |\n"
+        f"|------|-------|----------|\n"
+    ]
+    for i, t in enumerate(result.traces, 1):
+        trace_parts.append(f"| {i} | {t.agent_name} | {t.duration_ms}ms |\n")
+
+    trace_json = json.dumps(
+        [t.model_dump() for t in result.traces], indent=2
+    )
+    trace_parts.append(f"\n<details><summary>Raw JSON</summary>\n\n```json\n{trace_json}\n```\n</details>")
+    return "".join(trace_parts)
+
+
+def _make_trace_file(result: PipelineResult) -> str | None:
+    if not result.traces:
+        return None
+    trace_json = json.dumps(
+        [t.model_dump() for t in result.traces], indent=2
+    )
+    trace_file = tempfile.NamedTemporaryFile(
+        mode="w", suffix=".json", prefix="craftpilot-trace-", delete=False
+    )
+    trace_file.write(trace_json)
+    trace_file.close()
+    return trace_file.name
+
+
+def _build_export_text(result: PipelineResult) -> str:
+    """Build a plain text listing ready to copy-paste to Etsy or Instagram."""
+    lines = []
+
+    if result.copy_data:
+        c = result.copy_data
+        lines.append(f"PRODUCT TITLE: {c.title}")
+        lines.append("")
+        lines.append(f"SHORT DESCRIPTION: {c.short_desc}")
+        lines.append("")
+        lines.append("FULL DESCRIPTION:")
+        lines.append(c.long_desc)
+        lines.append("")
+
+    if result.catalog:
+        cat = result.catalog
+        lines.append(f"CATEGORY: {cat.category} / {cat.sub_category}")
+        lines.append(f"MATERIALS: {', '.join(cat.materials)}")
+        lines.append(f"COLORS: {', '.join(cat.colors)}")
+        lines.append(f"SIZE: {cat.estimated_size}")
+        lines.append(f"TAGS: {', '.join(cat.tags)}")
+        lines.append("")
+
+    if result.pricing:
+        p = result.pricing
+        lines.append(f"SUGGESTED PRICE: ${p.suggested_price_min} - ${p.suggested_price_max}")
+        lines.append("")
+
+    if result.copy_data:
+        lines.append("INSTAGRAM CAPTIONS:")
+        for i, cap in enumerate(result.copy_data.captions, 1):
+            lines.append(f"  {i}. {cap}")
+        lines.append("")
+
+    lines.append("---")
+    lines.append("Generated by CraftPilot | craftpilot.hf.space")
+
+    return "\n".join(lines)
+
+
+def _snapshot(result: PipelineResult, status: str):
+    """Yield a snapshot of all outputs from current pipeline state."""
+    summary = _format_summary(result) if result.image_description else ""
+    summary = f"**{status}**\n\n---\n\n{summary}" if summary else f"**{status}**"
+    return (
+        summary,
+        _format_vision(result),
+        _format_catalog(result),
+        _format_copy(result),
+        _format_pricing(result),
+        _format_traces(result),
+        gr.skip(),  # trace file — only on completion
+        gr.skip(),  # export file — only on completion
+    )
+
+
+def analyze_craft(
+    image: Image.Image | None,
+    craft_type: str,
+    user_notes: str,
+    material_cost: str,
+    time_hours: str,
+):
+    """Streaming generator: yields results as each agent completes."""
+    empty = ("",) * 7 + (None, None)
+
+    if image is None:
+        yield ("Upload an image to get started.",) + ("",) * 5 + (None, None)
+        return
+
+    if not craft_type:
+        yield ("Please select a craft type.",) + ("",) * 5 + (None, None)
+        return
+
+    cost = float(material_cost) if material_cost else None
+    hours = float(time_hours) if time_hours else None
+    notes = user_notes.strip() or None
+
+    try:
+        # Load model
+        yield ("**Loading model...**",) + ("",) * 5 + (None, None)
+        llm = get_client()
+
+        start = time.monotonic()
+        traces: list[AgentTrace] = []
+        result = PipelineResult(image_description="")
+
+        # Stage 1: Vision
+        yield _snapshot(result, "Analyzing image...")
+        description, vision_ms = llm.describe_image(image, VISION_PROMPT)
+        traces.append(AgentTrace(
+            agent_name="vision", input_text="[image]",
+            output_data={"description": description},
+            duration_ms=vision_ms, model_id=llm.model_id,
+        ))
+        result.image_description = description
+        result.traces = list(traces)
+        result.total_duration_ms = int((time.monotonic() - start) * 1000)
+        yield _snapshot(result, "Vision complete. Cataloging item...")
+
+        # Stage 2: Cataloger
+        try:
+            catalog_result, catalog_trace = asyncio.run(
+                cataloger.run(llm, description, craft_type.lower(), notes)
+            )
+            traces.append(catalog_trace)
+            result.catalog = catalog_result
+        except Exception as e:
+            logger.warning("Cataloger failed: %s", e)
+        result.traces = list(traces)
+        result.total_duration_ms = int((time.monotonic() - start) * 1000)
+        yield _snapshot(result, "Catalog done. Writing copy...")
+
+        # Stage 3: Copywriter (needs catalog — skip if catalog failed)
+        if result.catalog:
+            try:
+                copy_result, copy_trace = asyncio.run(
+                    copywriter.run(llm, craft_type.lower(), result.catalog, notes)
+                )
+                traces.append(copy_trace)
+                result.copy_data = copy_result
+            except Exception as e:
+                logger.warning("Copywriter failed: %s", e)
+        result.traces = list(traces)
+        result.total_duration_ms = int((time.monotonic() - start) * 1000)
+        yield _snapshot(result, "Copy done. Calculating pricing...")
+
+        # Stage 4: Pricer (needs catalog — skip if catalog failed)
+        if result.catalog:
+            try:
+                price_result, price_trace = asyncio.run(
+                    pricer.run(llm, craft_type.lower(), result.catalog, cost, hours)
+                )
+                traces.append(price_trace)
+                result.pricing = price_result
+            except Exception as e:
+                logger.warning("Pricer failed: %s", e)
+        result.traces = list(traces)
+        result.total_duration_ms = int((time.monotonic() - start) * 1000)
+
+        # Build export file
+        export_text = _build_export_text(result)
+        export_file = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".txt", prefix="craftpilot-listing-", delete=False
+        )
+        export_file.write(export_text)
+        export_file.close()
+
+        # Final yield with everything
+        yield (
+            _format_summary(result),
+            _format_vision(result),
+            _format_catalog(result),
+            _format_copy(result),
+            _format_pricing(result),
+            _format_traces(result),
+            _make_trace_file(result),
+            export_file.name,
+        )
+
+    except Exception as e:
+        logger.exception("Pipeline failed")
+        yield (f"**Error:** {e}",) + ("",) * 5 + (None, None)
+
+
+def build_ui() -> gr.Blocks:
+    """Build the Gradio interface."""
+    with gr.Blocks(
+        title="CraftPilot \u2014 AI Craft Business Assistant",
+    ) as app:
+        # Header
+        gr.Markdown(
+            "# CraftPilot\n"
+            "### Photo in, marketplace listing out\n"
+            "Upload a photo of your handmade craft and get catalog data, "
+            "product copy, social captions, and fair pricing \u2014 all from a "
+            "single small model running locally. No cloud APIs.",
+            elem_id="craft-header",
+        )
+
+        with gr.Row(equal_height=False):
+            # Left: inputs
+            with gr.Column(scale=1, min_width=340):
+                with gr.Group(elem_id="input-panel"):
+                    image_input = gr.Image(
+                        label="Your Craft",
+                        type="pil",
+                        height=360,
+                    )
+                    craft_type = gr.Dropdown(
+                        choices=CRAFT_TYPES,
+                        label="Craft Type",
+                        value="Crochet",
+                    )
+                    user_notes = gr.Textbox(
+                        label="Notes (optional)",
+                        placeholder="e.g. Made with organic cotton, took 3 evenings...",
+                        lines=2,
+                    )
+                    with gr.Row():
+                        material_cost = gr.Textbox(
+                            label="Material Cost ($)",
+                            placeholder="e.g. 15",
+                        )
+                        time_hours = gr.Textbox(
+                            label="Time Spent (hrs)",
+                            placeholder="e.g. 8",
+                        )
+                    analyze_btn = gr.Button(
+                        "Analyze My Craft",
+                        variant="primary",
+                        size="lg",
+                        elem_id="analyze-btn",
+                    )
+
+                gr.Examples(
+                    examples=[
+                        ["examples/crochet.png", "Crochet", "Handmade amigurumi with cotton yarn", "16", "6"],
+                        ["examples/embroidery.jpeg", "Embroidery", "Hand-stitched floral pattern on Jeans", "20", "10"],
+                        ["examples/sew_keychain.jpeg", "Sewing", "Fabric keychain with felt and thread", "5", "2"],
+                    ],
+                    inputs=[image_input, craft_type, user_notes, material_cost, time_hours],
+                    label="Try these examples",
+                )
+
+            # Right: outputs
+            with gr.Column(scale=2, min_width=500, elem_id="output-panel"):
+                with gr.Tabs():
+                    with gr.Tab("Summary"):
+                        summary_output = gr.Markdown(
+                            value="*Your results will appear here after analysis.*",
+                            elem_classes=["prose"],
+                        )
+                    with gr.Tab("Vision"):
+                        vision_output = gr.Markdown(elem_classes=["prose"])
+                    with gr.Tab("Catalog"):
+                        catalog_output = gr.Markdown(elem_classes=["prose"])
+                    with gr.Tab("Copy"):
+                        copy_output = gr.Markdown(elem_classes=["prose"])
+                    with gr.Tab("Pricing"):
+                        price_output = gr.Markdown(elem_classes=["prose"])
+                    with gr.Tab("Agent Traces"):
+                        trace_output = gr.Markdown(elem_classes=["prose"])
+                        trace_download = gr.File(
+                            label="Download Trace JSON",
+                            file_count="single",
+                            interactive=False,
+                        )
+
+                with gr.Row():
+                    export_download = gr.File(
+                        label="Download Listing (Etsy/Instagram ready)",
+                        file_count="single",
+                        interactive=False,
+                    )
+
+        analyze_btn.click(
+            fn=analyze_craft,
+            inputs=[
+                image_input,
+                craft_type,
+                user_notes,
+                material_cost,
+                time_hours,
+            ],
+            outputs=[
+                summary_output,
+                vision_output,
+                catalog_output,
+                copy_output,
+                price_output,
+                trace_output,
+                trace_download,
+                export_download,
+            ],
+        )
+
+        # Footer
+        gr.Markdown(
+            "Built for the Build Small Hackathon 2026 \u00b7 Backyard AI track  \n"
+            "MiniCPM-V 2.6 (~8B) via llama.cpp \u00b7 No cloud APIs  \n"
+            "Llama Champion \u00b7 Off the Grid \u00b7 Sharing is Caring \u00b7 Field Notes",
+            elem_id="craft-footer",
+        )
+
+    return app
+
+
+if __name__ == "__main__":
+    # Pre-load models at startup (avoids 60s request timeout on HF Spaces)
+    logger.info("Pre-loading models at startup...")
+    try:
+        get_client()
+        logger.info("Models ready!")
+    except Exception as e:
+        logger.error("Failed to load models: %s", e)
+
+    theme = gr.themes.Soft(
+        primary_hue="amber",
+        secondary_hue="orange",
+        neutral_hue="stone",
+        font=gr.themes.GoogleFont("Source Sans 3"),
+        font_mono=gr.themes.GoogleFont("JetBrains Mono"),
+    )
+    app = build_ui()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        theme=theme,
+        css=CUSTOM_CSS,
+        head=CUSTOM_HEAD,
+    )

requirements.txt

@@ -0,0 +1,7 @@
+--extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu/
+gradio>=4.0.0
+llama-cpp-python>=0.3.0
+huggingface_hub>=0.20.0
+Pillow>=10.0.0
+pydantic>=2.0.0
+Jinja2>=3.1.0