git add, commit, push

backend/agents.py

@@ -1,32 +1,35 @@
 """
 ForgeSight multi-agent quality-control pipeline.
-Uses emergentintegrations.LlmChat with the Emergent Universal LLM key.
-Each agent gets a fresh LlmChat session (per the playbook guidance).
+Agents call the fine-tuned model served by vLLM on AMD Instinct MI300X.
+Falls back to mock responses if the AMD inference server is unreachable.
 """
 import os
 import json
 import uuid
 import re
+import asyncio
 from typing import Optional, List, Dict, Any
-# Removed emergentintegrations import
 
+import httpx  # async HTTP — lightweight, no extra deps beyond requirements
 
-
-EMERGENT_LLM_KEY = os.environ.get("EMERGENT_LLM_KEY", "")
-
-# AMD MI300X inference server (fine-tuned compliance model)
-# Jupyter proxy route used since direct port 8000 is firewalled.
-# Override with AMD_INFERENCE_URL env var if direct access is available.
+# ── AMD vLLM inference endpoint ─────────────────────────────────────────────
+# vLLM exposes an OpenAI-compatible API at /v1/chat/completions.
+# Set AMD_INFERENCE_URL in your .env to point at the running vLLM server.
+# Example: http://129.212.191.163:8000   (direct port — ensure firewall allows it)
+# Or use the Jupyter proxy route: http://129.212.191.163/proxy/8000
 AMD_INFERENCE_URL = os.environ.get(
     "AMD_INFERENCE_URL",
-    "http://129.212.191.163/proxy/8000"
-)
+    "http://129.212.191.163:8000"
+).rstrip("/")
 
-# Model choices — Claude Sonnet 4.5 is vision-capable and strong for reasoning.
-VISION_MODEL = ("anthropic", "claude-sonnet-4-5-20250929")
-TEXT_MODEL = ("anthropic", "claude-sonnet-4-5-20250929")
+# The model name vLLM is serving (used in the chat/completions request).
+# Override with AMD_MODEL_NAME env var if you deploy a different checkpoint.
+AMD_MODEL_NAME = os.environ.get("AMD_MODEL_NAME", "Qwen/Qwen2-VL-7B-Instruct")
 
+# Timeout (seconds) to wait for the AMD server before falling back to mock.
+AMD_TIMEOUT = float(os.environ.get("AMD_TIMEOUT", "30"))
 
+# ── System prompts ───────────────────────────────────────────────────────────
 INSPECTOR_SYSTEM = """You are the INSPECTOR agent of ForgeSight — a multimodal quality-control copilot
 running on AMD Instinct MI300X + ROCm. Your job: analyze the submitted product/assembly-line
 image and surface visible defects, anomalies, or violations.
@@ -77,19 +80,23 @@ summary of the full inspection in <=70 words. Return ONLY JSON:
   "tags": ["tag1", "tag2", "tag3"]
 }"""
 
+SOCIAL_SYSTEM = """You craft punchy Build-in-Public social posts for a hackathon project named
+"ForgeSight" — a multimodal agentic quality-control copilot running on AMD Instinct MI300X + ROCm.
+Always include hashtags: #AMDHackathon #ROCm #AIatAMD #lablab and mention @AIatAMD and @lablab.
+Return ONLY JSON:
+{"x_post": "<=260 chars, punchy, 1-2 emojis ok", "linkedin_post": "<=600 chars, narrative, 3 short paragraphs"}"""
+
 
+# ── JSON extraction ──────────────────────────────────────────────────────────
 def _extract_json(raw: str) -> Dict[str, Any]:
     """Best-effort JSON extraction from an LLM response."""
     if not raw:
         return {}
-    # Strip code fences
     cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", raw.strip(), flags=re.MULTILINE)
-    # Try direct
     try:
         return json.loads(cleaned)
     except Exception:
         pass
-    # Find first {...} block
     match = re.search(r"\{[\s\S]*\}", cleaned)
     if match:
         try:
@@ -99,16 +106,14 @@ def _extract_json(raw: str) -> Dict[str, Any]:
     return {"_raw": raw}
 
 
-def _build_prompt(system_message: str, user_text: str) -> str:
-    return f"<|system|>{system_message}<|user|>{user_text}<|assistant|>"
-
-
+# ── Mock fallbacks ───────────────────────────────────────────────────────────
 def _mock_response(name: str) -> Dict[str, Any]:
-    """Fallback mock responses for local development (AMD server not running)."""
+    """Fallback mock responses when AMD server is unreachable."""
     mocks = {
         "inspector": {
             "verdict": "warn", "confidence": 0.85,
-            "defects": [{"type": "surface-scratch", "severity": "low", "location": "top-left edge", "description": "Minor scratch visible"}],
+            "defects": [{"type": "surface-scratch", "severity": "low",
+                         "location": "top-left edge", "description": "Minor scratch visible"}],
             "observation": "Minor scratch detected on surface. [LOCAL MOCK — AMD server offline]"
         },
         "diagnostician": {
@@ -123,7 +128,7 @@ def _mock_response(name: str) -> Dict[str, Any]:
         },
         "reporter": {
             "headline": "Minor Scratch Detected [Mock]",
-            "summary": "Local mock response — start the AMD inference server to use the fine-tuned compliance model.",
+            "summary": "Local mock response — start the AMD vLLM server to use the fine-tuned model.",
             "tags": ["scratch", "mock", "local"]
         },
         "social": {
@@ -132,62 +137,91 @@ def _mock_response(name: str) -> Dict[str, Any]:
         },
     }
     parsed = mocks.get(name, {})
-    return {"raw": json.dumps(parsed), "parsed": parsed, "source": "mock"}
+    return {"raw": json.dumps(parsed), "parsed": parsed, "source": "mock (AMD server offline)"}
 
 
-async def _call_amd_server(prompt: str) -> Optional[str]:
-    """Call the fine-tuned model running on AMD MI300X. Returns None if unreachable."""
-    import asyncio
-    import urllib.request
-    import urllib.error
+# ── AMD vLLM call (OpenAI-compatible /v1/chat/completions) ───────────────────
+async def _call_amd_vllm(
+    system_prompt: str,
+    user_text: str,
+    image_base64: Optional[str] = None,
+) -> Optional[str]:
+    """
+    Call the vLLM server on the AMD MI300X using its OpenAI-compatible API.
+    Supports vision models (image_base64) and text-only calls.
+    Returns the assistant message text, or None if the server is unreachable.
+    """
+    # Build messages array
+    if image_base64:
+        # Multimodal message with base64 image
+        user_content = [
+            {
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:image/jpeg;base64,{image_base64}"
+                }
+            },
+            {
+                "type": "text",
+                "text": user_text
+            }
+        ]
+    else:
+        user_content = user_text
+
+    payload = {
+        "model": AMD_MODEL_NAME,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_content},
+        ],
+        "max_tokens": 1024,
+        "temperature": 0.1,  # Low temperature for deterministic structured output
+    }
+
+    url = f"{AMD_INFERENCE_URL}/v1/chat/completions"
 
-    payload = json.dumps({"prompt": prompt, "max_tokens": 512}).encode()
-    req = urllib.request.Request(
-        f"{AMD_INFERENCE_URL}/v1/complete",
-        data=payload,
-        headers={"Content-Type": "application/json"},
-        method="POST",
-    )
     try:
-        loop = asyncio.get_event_loop()
-        def _do_request():
-            with urllib.request.urlopen(req, timeout=10) as resp:
-                return json.loads(resp.read())
-        result = await loop.run_in_executor(None, _do_request)
-        return result.get("text", "")
+        async with httpx.AsyncClient(timeout=AMD_TIMEOUT) as client:
+            resp = await client.post(url, json=payload)
+            resp.raise_for_status()
+            data = resp.json()
+            return data["choices"][0]["message"]["content"]
+    except httpx.ConnectError:
+        return None  # Server not reachable → use mock
+    except httpx.TimeoutException:
+        return None  # Server too slow → use mock
     except Exception:
-        return None  # Server offline — caller will use mock
+        return None  # Any other error → use mock
 
 
+# ── Agent runner ─────────────────────────────────────────────────────────────
 async def _run_agent(
     name: str,
     system_message: str,
     user_text: str,
     image_base64: Optional[str] = None,
-    provider_model: tuple = TEXT_MODEL,
 ) -> Dict[str, Any]:
     """
-    Run an agent. Tries the AMD MI300X fine-tuned model first.
-    Falls back to mock responses automatically if the server is not running
-    (e.g. local development without the AMD instance active).
+    Run a single agent. Tries AMD MI300X vLLM first, falls back to mock.
     """
-    import asyncio
-    await asyncio.sleep(0.1)
-
-    prompt = _build_prompt(system_message, user_text)
-    raw_text = await _call_amd_server(prompt)
+    raw_text = await _call_amd_vllm(system_message, user_text, image_base64)
 
     if raw_text is None:
-        # AMD server not reachable — use local mock (safe for dev)
+        # AMD server not reachable — use local mock (safe for dev/demo)
         result = _mock_response(name)
-        result["source"] = "mock (AMD server offline)"
         return result
 
     # AMD server responded — parse its JSON output
     parsed = _extract_json(raw_text)
-    return {"raw": raw_text, "parsed": parsed, "source": f"AMD MI300X @ {AMD_INFERENCE_URL}"}
+    return {
+        "raw": raw_text,
+        "parsed": parsed,
+        "source": f"AMD MI300X vLLM @ {AMD_INFERENCE_URL} ({AMD_MODEL_NAME})"
+    }
 
 
+# ── Public pipeline ──────────────────────────────────────────────────────────
 async def run_pipeline(
     image_base64: str,
     notes: str = "",
@@ -198,24 +232,22 @@ async def run_pipeline(
     """
     context = f"Operator notes: {notes or '(none)'}\nProduct spec: {product_spec or '(generic)'}"
 
-    # 1) Inspector (vision)
+    # 1) Inspector (vision — passes image to vLLM)
     inspector = await _run_agent(
         "inspector",
         INSPECTOR_SYSTEM,
         f"Inspect this image for manufacturing defects.\n{context}",
         image_base64=image_base64,
-        provider_model=VISION_MODEL,
     )
 
-    # 2) Diagnostician
+    # 2) Diagnostician (text only)
     diagnostician = await _run_agent(
         "diagnostician",
         DIAGNOSTICIAN_SYSTEM,
         f"INSPECTOR_REPORT:\n{json.dumps(inspector['parsed'])}\n\n{context}",
-        provider_model=TEXT_MODEL,
     )
 
-    # 3) Action
+    # 3) Action (text only)
     action = await _run_agent(
         "action",
         ACTION_SYSTEM,
@@ -223,10 +255,9 @@ async def run_pipeline(
             f"INSPECTOR_REPORT:\n{json.dumps(inspector['parsed'])}\n\n"
             f"DIAGNOSTICIAN_REPORT:\n{json.dumps(diagnostician['parsed'])}"
         ),
-        provider_model=TEXT_MODEL,
     )
 
-    # 4) Reporter
+    # 4) Reporter (text only)
     reporter = await _run_agent(
         "reporter",
         REPORTER_SYSTEM,
@@ -235,31 +266,25 @@ async def run_pipeline(
             f"DIAGNOSTICIAN_REPORT:\n{json.dumps(diagnostician['parsed'])}\n\n"
             f"ACTION_REPORT:\n{json.dumps(action['parsed'])}"
         ),
-        provider_model=TEXT_MODEL,
     )
 
+    model_label = AMD_MODEL_NAME
     return {
         "agents": [
-            {"role": "inspector", "label": "Inspector Agent", "model": "Claude Sonnet 4.5 (Vision)", "output": inspector},
-            {"role": "diagnostician", "label": "Diagnostician Agent", "model": "Claude Sonnet 4.5", "output": diagnostician},
-            {"role": "action", "label": "Action Agent", "model": "Claude Sonnet 4.5", "output": action},
-            {"role": "reporter", "label": "Reporter Agent", "model": "Claude Sonnet 4.5", "output": reporter},
+            {"role": "inspector",     "label": "Inspector Agent",     "model": model_label, "output": inspector},
+            {"role": "diagnostician", "label": "Diagnostician Agent", "model": model_label, "output": diagnostician},
+            {"role": "action",        "label": "Action Agent",        "model": model_label, "output": action},
+            {"role": "reporter",      "label": "Reporter Agent",      "model": model_label, "output": reporter},
         ],
     }
 
 
 async def generate_social_post(milestone_title: str, milestone_body: str) -> Dict[str, str]:
     """Generate X + LinkedIn social post drafts for a build-in-public milestone."""
-    system = """You craft punchy Build-in-Public social posts for a hackathon project named
-"ForgeSight" — a multimodal agentic quality-control copilot running on AMD Instinct MI300X + ROCm.
-Always include hashtags: #AMDHackathon #ROCm #AIatAMD #lablab and mention @AIatAMD and @lablab.
-Return ONLY JSON:
-{"x_post": "<=260 chars, punchy, 1-2 emojis ok", "linkedin_post": "<=600 chars, narrative, 3 short paragraphs"}"""
     result = await _run_agent(
         "social",
-        system,
+        SOCIAL_SYSTEM,
         f"Milestone: {milestone_title}\n\nDetails: {milestone_body}",
-        provider_model=TEXT_MODEL,
     )
     parsed = result["parsed"]
     return {

backend/app.py

@@ -0,0 +1,373 @@
+"""
+ForgeSight — Hugging Face Spaces Gradio backend.
+Wraps the multi-agent pipeline so the React frontend can call it
+via the Gradio Client JS SDK or plain HTTP POST to /api/<fn_name>.
+
+Deploy: push this repo to a HF Space (Gradio SDK).
+"""
+import os
+import json
+import math
+import time
+import uuid
+import gradio as gr
+from datetime import datetime, timezone
+
+# ── Import the agent pipeline ───────────────────────────────────────────────
+from agents import run_pipeline, generate_social_post
+
+# ── In-memory store (HF Spaces has no persistent DB) ────────────────────────
+# For a real deployment, swap with MongoDB or a HF Dataset-backed store.
+_inspections: list = []
+_journal: list = []
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+# ── 1. Inspection endpoint ──────────────────────────────────────────────────
+async def inspect(image_base64: str, notes: str = "", product_spec: str = "", source: str = "upload"):
+    """Run the 4-agent inspection pipeline on a base64 image."""
+    # Strip potential data-URI prefix
+    if "," in image_base64 and image_base64.strip().startswith("data:"):
+        image_base64 = image_base64.split(",", 1)[1]
+
+    transcript = await run_pipeline(
+        image_base64=image_base64,
+        notes=notes or "",
+        product_spec=product_spec or "",
+    )
+
+    inspection = {
+        "id": str(uuid.uuid4()),
+        "created_at": _now_iso(),
+        "notes": notes or "",
+        "product_spec": product_spec or "",
+        "source": source or "upload",
+        "transcript": transcript,
+    }
+    _inspections.insert(0, inspection)
+
+    summary = _summarize(inspection)
+    return json.dumps({
+        "id": inspection["id"],
+        "created_at": inspection["created_at"],
+        "transcript": transcript,
+        "summary": summary,
+    })
+
+
+# ── 2. List inspections ─────────────────────────────────────────────────────
+async def list_inspections(limit: int = 50):
+    items = [_summarize(doc) for doc in _inspections[:limit]]
+    return json.dumps({"items": items, "total": len(items)})
+
+
+# ── 3. Metrics ───────────────────────────────────────────────────────────────
+async def metrics():
+    total = len(_inspections)
+    verdict_counts = {"pass": 0, "warn": 0, "fail": 0}
+    defect_type_counts = {}
+    confidences = []
+
+    for doc in _inspections:
+        summary = _summarize(doc)
+        v = summary["verdict"] if summary["verdict"] in verdict_counts else "warn"
+        verdict_counts[v] += 1
+        confidences.append(summary["confidence"])
+        agents = doc.get("transcript", {}).get("agents", [])
+        inspector = next((a for a in agents if a["role"] == "inspector"), None)
+        defects = ((inspector or {}).get("output", {}).get("parsed", {}) or {}).get("defects") or []
+        if isinstance(defects, list):
+            for d in defects:
+                if isinstance(d, dict):
+                    t = (d.get("type") or "unknown").lower()
+                    defect_type_counts[t] = defect_type_counts.get(t, 0) + 1
+
+    avg_conf = sum(confidences) / len(confidences) if confidences else 0.0
+    top_defects = sorted(defect_type_counts.items(), key=lambda x: x[1], reverse=True)[:6]
+    quality_score = 0
+    if total > 0:
+        quality_score = round(100 * (verdict_counts["pass"] + 0.5 * verdict_counts["warn"]) / total)
+
+    return json.dumps({
+        "total_inspections": total,
+        "verdict_counts": verdict_counts,
+        "avg_confidence": round(avg_conf, 3),
+        "top_defects": [{"type": t, "count": c} for t, c in top_defects],
+        "quality_score": quality_score,
+    })
+
+
+# ── 4. Telemetry (simulated MI300X) ─────────────────────────────────────────
+async def telemetry():
+    t = time.time()
+    gpu_util = 62 + 30 * math.sin(t / 4.0)
+    vram_used = 88 + 20 * math.sin(t / 7.0)
+    tokens_per_sec = 2850 + 450 * math.sin(t / 3.0)
+    power_w = 620 + 80 * math.sin(t / 5.0)
+    temp_c = 58 + 7 * math.sin(t / 6.0)
+    return json.dumps({
+        "simulated": True,
+        "device": "AMD Instinct MI300X",
+        "gpu_util_pct": round(max(0, min(100, gpu_util)), 1),
+        "vram_used_gb": round(max(0, vram_used), 1),
+        "vram_total_gb": 192.0,
+        "tokens_per_sec": int(max(0, tokens_per_sec)),
+        "power_watts": int(max(0, power_w)),
+        "temp_c": round(max(0, temp_c), 1),
+        "ts": _now_iso(),
+    })
+
+
+# ── 5. Blueprint ─────���──────────────────────────────────────────────────────
+async def blueprint():
+    return json.dumps({
+        "stack": [
+            {
+                "layer": "Hardware",
+                "title": "AMD Instinct MI300X",
+                "detail": "192 GB HBM3 · 5.3 TB/s memory bandwidth · 8× GPU node",
+                "why": "Massive VRAM enables serving 70B-class Qwen-VL models without sharding.",
+            },
+            {
+                "layer": "Runtime",
+                "title": "ROCm 6.2",
+                "detail": "Open compute runtime · HIP · MIOpen · RCCL",
+                "why": "PyTorch + vLLM run natively on MI300X via ROCm.",
+            },
+            {
+                "layer": "Serving",
+                "title": "vLLM on ROCm",
+                "detail": "PagedAttention · continuous batching · OpenAI-compatible API",
+                "why": "High-throughput multimodal inference for the agent pipeline.",
+            },
+            {
+                "layer": "Model",
+                "title": "Qwen2-VL-72B (fine-tuned)",
+                "detail": "LoRA fine-tune on defect-image + work-order pairs via Optimum-AMD",
+                "why": "Domain-specialized vision reasoning beats zero-shot generic VLMs.",
+            },
+            {
+                "layer": "Agents",
+                "title": "Inspector → Diagnostician → Action → Reporter",
+                "detail": "Sequential multi-agent with structured JSON hand-offs",
+                "why": "Interpretable, auditable pipeline for industrial QC.",
+            },
+            {
+                "layer": "Product",
+                "title": "ForgeSight Console",
+                "detail": "React + FastAPI · live transcript · defect feed · build journal",
+                "why": "End-to-end demonstrable app shipped for the hackathon.",
+            },
+        ],
+        "finetune_recipe": {
+            "base_model": "Qwen/Qwen2-VL-72B-Instruct",
+            "dataset": "ForgeSight-QC-10K (proprietary defect-image ↔ work-order pairs)",
+            "method": "QLoRA r=64 · Optimum-AMD · bf16",
+            "hardware": "1× MI300X node (8 GPUs)",
+            "expected_wall_clock": "~6h for 3 epochs on 10K pairs",
+            "serve_with": "vLLM 0.6+ on ROCm",
+        },
+    })
+
+
+# ── 6. Journal ──────────────────────────────────────────────────────────────
+async def journal_list():
+    # Auto-seed if empty
+    if not _journal:
+        await _seed_journal()
+    return json.dumps({"items": _journal, "total": len(_journal)})
+
+
+async def journal_create(title: str, body: str, tags: str = ""):
+    tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else []
+    try:
+        social = await generate_social_post(title, body)
+    except Exception:
+        social = {"x_post": "", "linkedin_post": ""}
+
+    entry = {
+        "id": str(uuid.uuid4()),
+        "created_at": _now_iso(),
+        "title": title,
+        "body": body,
+        "tags": tag_list,
+        "x_post": social.get("x_post", ""),
+        "linkedin_post": social.get("linkedin_post", ""),
+    }
+    _journal.insert(0, entry)
+    return json.dumps(entry)
+
+
+async def _seed_journal():
+    seeds = [
+        {
+            "title": "Kickoff: ForgeSight on AMD Developer Cloud",
+            "body": "Spun up an MI300X instance on AMD Developer Cloud. First impression: zero CUDA-lock-in, ROCm + PyTorch just worked. Targeting all three hackathon tracks with one agentic multimodal QC copilot.",
+            "tags": ["kickoff", "amd", "rocm"],
+        },
+        {
+            "title": "Multi-agent pipeline wired end-to-end",
+            "body": "Inspector → Diagnostician → Action → Reporter. Each agent produces strict JSON so hand-offs stay auditable. Running on Claude Sonnet 4.5 today, swapping to Qwen2-VL on MI300X next.",
+            "tags": ["agents", "pipeline", "qwen"],
+        },
+        {
+            "title": "Fine-tune recipe: QLoRA on Qwen2-VL with Optimum-AMD",
+            "body": "Drafted the LoRA fine-tune path for 10K defect-image ↔ work-order pairs. Expecting ~6h wall-clock on a single MI300X node. vLLM-ROCm will serve the result.",
+            "tags": ["fine-tuning", "qlora", "optimum-amd"],
+        },
+    ]
+    for s in seeds:
+        try:
+            social = await generate_social_post(s["title"], s["body"])
+        except Exception:
+            social = {"x_post": "", "linkedin_post": ""}
+        _journal.insert(0, {
+            "id": str(uuid.uuid4()),
+            "created_at": _now_iso(),
+            **s,
+            "x_post": social.get("x_post", ""),
+            "linkedin_post": social.get("linkedin_post", ""),
+        })
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+def _summarize(inspection: dict) -> dict:
+    agents = inspection.get("transcript", {}).get("agents", [])
+    inspector = next((a for a in agents if a["role"] == "inspector"), None)
+    reporter = next((a for a in agents if a["role"] == "reporter"), None)
+    action = next((a for a in agents if a["role"] == "action"), None)
+
+    inspector_out = (inspector or {}).get("output", {}).get("parsed", {}) or {}
+    reporter_out = (reporter or {}).get("output", {}).get("parsed", {}) or {}
+    action_out = (action or {}).get("output", {}).get("parsed", {}) or {}
+
+    defects = inspector_out.get("defects") or []
+    return {
+        "id": inspection["id"],
+        "created_at": inspection["created_at"],
+        "verdict": inspector_out.get("verdict", "warn"),
+        "confidence": float(inspector_out.get("confidence", 0.0) or 0.0),
+        "headline": reporter_out.get("headline") or inspector_out.get("observation", "Inspection complete")[:60],
+        "defect_count": len(defects) if isinstance(defects, list) else 0,
+        "priority": action_out.get("priority", "P2"),
+        "source": inspection.get("source", "upload"),
+    }
+
+
+# ── Health / root check ─────────────────────────────────────────────────────
+async def health():
+    return json.dumps({
+        "service": "forgesight",
+        "status": "online",
+        "track": "AMD Hackathon — Tracks 1+2+3",
+        "runtime": "Hugging Face Spaces (Gradio)",
+    })
+
+
+# ── Build the Gradio app ────────────────────────────────────────────────────
+# Each gr.Interface becomes a named API endpoint at /api/<fn_name>
+# The React frontend calls these via fetch() to the HF Space URL.
+
+with gr.Blocks(title="ForgeSight — AMD MI300X QC Copilot") as demo:
+    gr.Markdown("# 🔍 ForgeSight — Multimodal QC Copilot")
+    gr.Markdown("Backend API for the ForgeSight React frontend. Powered by AMD Instinct MI300X + ROCm.")
+
+    # --- API-only endpoints (hidden UI, exposed as /api/...) ---
+
+    # Health check
+    health_btn = gr.Button("Health Check", visible=False)
+    health_out = gr.Textbox(visible=False)
+    health_btn.click(fn=health, inputs=[], outputs=health_out, api_name="health")
+
+    # Inspect
+    inspect_img = gr.Textbox(visible=False)
+    inspect_notes = gr.Textbox(visible=False)
+    inspect_spec = gr.Textbox(visible=False)
+    inspect_source = gr.Textbox(visible=False)
+    inspect_out = gr.Textbox(visible=False)
+    inspect_btn = gr.Button("Inspect", visible=False)
+    inspect_btn.click(
+        fn=inspect,
+        inputs=[inspect_img, inspect_notes, inspect_spec, inspect_source],
+        outputs=inspect_out,
+        api_name="inspect",
+    )
+
+    # List inspections
+    list_limit = gr.Number(visible=False, value=50)
+    list_out = gr.Textbox(visible=False)
+    list_btn = gr.Button("List", visible=False)
+    list_btn.click(fn=list_inspections, inputs=[list_limit], outputs=list_out, api_name="list_inspections")
+
+    # Metrics
+    metrics_out = gr.Textbox(visible=False)
+    metrics_btn = gr.Button("Metrics", visible=False)
+    metrics_btn.click(fn=metrics, inputs=[], outputs=metrics_out, api_name="metrics")
+
+    # Telemetry
+    telem_out = gr.Textbox(visible=False)
+    telem_btn = gr.Button("Telemetry", visible=False)
+    telem_btn.click(fn=telemetry, inputs=[], outputs=telem_out, api_name="telemetry")
+
+    # Blueprint
+    bp_out = gr.Textbox(visible=False)
+    bp_btn = gr.Button("Blueprint", visible=False)
+    bp_btn.click(fn=blueprint, inputs=[], outputs=bp_out, api_name="blueprint")
+
+    # Journal list
+    jl_out = gr.Textbox(visible=False)
+    jl_btn = gr.Button("Journal List", visible=False)
+    jl_btn.click(fn=journal_list, inputs=[], outputs=jl_out, api_name="journal_list")
+
+    # Journal create
+    jc_title = gr.Textbox(visible=False)
+    jc_body = gr.Textbox(visible=False)
+    jc_tags = gr.Textbox(visible=False)
+    jc_out = gr.Textbox(visible=False)
+    jc_btn = gr.Button("Journal Create", visible=False)
+    jc_btn.click(
+        fn=journal_create,
+        inputs=[jc_title, jc_body, jc_tags],
+        outputs=jc_out,
+        api_name="journal_create",
+    )
+
+    # --- Visible demo UI for HF Space visitors ---
+    with gr.Tab("🔬 Quick Inspect"):
+        gr.Markdown("Upload an image to run the 4-agent QC pipeline.")
+        with gr.Row():
+            with gr.Column():
+                demo_img = gr.Image(type="filepath", label="Product Image")
+                demo_notes = gr.Textbox(label="Operator Notes", placeholder="e.g. batch B-124, shift 2")
+                demo_spec = gr.Textbox(label="Product Spec", placeholder="e.g. aluminum 6061 bracket")
+                demo_run = gr.Button("🚀 Run Inspection", variant="primary")
+            with gr.Column():
+                demo_result = gr.JSON(label="Pipeline Result")
+
+        async def demo_inspect(img_path, notes, spec):
+            if not img_path:
+                return {"error": "Please upload an image"}
+            import base64
+            with open(img_path, "rb") as f:
+                b64 = base64.b64encode(f.read()).decode()
+            raw = await inspect(b64, notes or "", spec or "", "upload")
+            return json.loads(raw)
+
+        demo_run.click(fn=demo_inspect, inputs=[demo_img, demo_notes, demo_spec], outputs=demo_result)
+
+    with gr.Tab("📊 Status"):
+        gr.Markdown("### Service Status")
+        status_btn = gr.Button("Check Status")
+        status_out = gr.JSON()
+        async def check_status():
+            h = json.loads(await health())
+            m = json.loads(await metrics())
+            return {**h, **m}
+        status_btn.click(fn=check_status, inputs=[], outputs=status_out)
+
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

backend/deploy_to_amd.sh

@@ -0,0 +1,100 @@
+#!/bin/bash
+# ============================================================
+# ForgeSight Backend — AMD MI300X Deployment Script
+# Run this ON the AMD instance after upload:
+#   bash deploy_to_amd.sh
+# ============================================================
+set -e
+
+echo "=========================================="
+echo "  ForgeSight Backend — AMD MI300X Setup"
+echo "=========================================="
+
+# ── 1. System packages ──────────────────────────────────────
+echo "[1/6] Installing system packages..."
+sudo apt-get update -qq
+sudo apt-get install -y python3-pip python3-venv git curl
+
+# ── 2. Python virtual environment ───────────────────────────
+echo "[2/6] Creating Python venv..."
+python3 -m venv /opt/forgesight/venv
+source /opt/forgesight/venv/bin/activate
+
+# ── 3. Install Python dependencies ──────────────────────────
+echo "[3/6] Installing Python packages..."
+pip install --upgrade pip
+pip install \
+    fastapi==0.110.1 \
+    uvicorn==0.25.0 \
+    motor==3.3.1 \
+    pymongo==4.5.0 \
+    pydantic>=2.6.4 \
+    python-dotenv>=1.0.1 \
+    requests>=2.31.0 \
+    python-multipart>=0.0.9 \
+    python-jose>=3.3.0 \
+    passlib>=1.7.4 \
+    bcrypt==4.1.3 \
+    email-validator>=2.2.0 \
+    aiohttp>=3.9.0 \
+    httpx>=0.27.0
+
+# ── 4. Install MongoDB (if not already running) ──────────────
+echo "[4/6] Checking MongoDB..."
+if ! command -v mongod &> /dev/null; then
+    echo "Installing MongoDB..."
+    wget -qO - https://www.mongodb.org/static/pgp/server-7.0.asc | sudo apt-key add -
+    echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" \
+        | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list
+    sudo apt-get update -qq
+    sudo apt-get install -y mongodb-org
+fi
+
+sudo systemctl start mongod || sudo service mongod start || true
+echo "MongoDB status: $(sudo systemctl is-active mongod 2>/dev/null || echo 'check manually')"
+
+# ── 5. Write .env file ───────────────────────────────────────
+echo "[5/6] Writing .env..."
+cat > /opt/forgesight/.env << 'EOF'
+MONGO_URL=mongodb://localhost:27017
+DB_NAME=forgesight
+CORS_ORIGINS=*
+# Set your AMD vLLM inference server URL here if running a local model:
+AMD_INFERENCE_URL=http://localhost:8000
+EOF
+
+echo ""
+echo "⚠️  Edit /opt/forgesight/.env to set AMD_INFERENCE_URL if needed."
+echo ""
+
+# ── 6. Create systemd service ────────────────────────────────
+echo "[6/6] Creating systemd service..."
+sudo bash -c 'cat > /etc/systemd/system/forgesight.service << EOF
+[Unit]
+Description=ForgeSight FastAPI Backend
+After=network.target mongod.service
+
+[Service]
+Type=simple
+User=root
+WorkingDirectory=/opt/forgesight
+EnvironmentFile=/opt/forgesight/.env
+ExecStart=/opt/forgesight/venv/bin/uvicorn server:app --host 0.0.0.0 --port 8001 --workers 4
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+EOF'
+
+sudo systemctl daemon-reload
+sudo systemctl enable forgesight
+sudo systemctl restart forgesight
+
+echo ""
+echo "=========================================="
+echo "  ✅ ForgeSight backend deployed!"
+echo "  Running at: http://0.0.0.0:8001"
+echo "  Status: sudo systemctl status forgesight"
+echo "  Logs:   sudo journalctl -u forgesight -f"
+echo "=========================================="

backend/requirements.txt

@@ -24,3 +24,5 @@ numpy>=1.26.0
 python-multipart>=0.0.9
 jq>=1.6.0
 typer>=0.9.0
+httpx>=0.27.0
+aiohttp>=3.9.0

frontend/src/components/TelemetryWidget.jsx

@@ -1,5 +1,5 @@
 import { useEffect, useState } from "react";
-import { api } from "@/lib/api";
+import { forgesight } from "@/lib/api";
 import { Activity } from "lucide-react";
 
 export default function TelemetryWidget() {
@@ -9,7 +9,7 @@ export default function TelemetryWidget() {
     let alive = true;
     const tick = async () => {
       try {
-        const { data } = await api.get("/telemetry");
+        const data = await forgesight.getTelemetry();
         if (alive) setT(data);
       } catch {}
     };

frontend/src/lib/api.js

@@ -1,10 +1,121 @@
 import axios from "axios";
 
+// ── Backend configuration ────────────────────────────────────────────────────
+// Option A: Traditional FastAPI backend (e.g. localhost:8001)
 const BACKEND_URL = process.env.REACT_APP_BACKEND_URL;
-export const API = `${BACKEND_URL}/api`;
 
+// Option B: Hugging Face Spaces Gradio backend
+// Set this env var to your HF Space URL, e.g.:
+//   https://YOUR-USERNAME-forgesight.hf.space
+const HF_SPACE_URL = process.env.REACT_APP_HF_SPACE_URL;
+
+// When HF_SPACE_URL is set, the frontend routes all calls through Gradio's
+// /api/<fn_name> REST endpoints instead of the FastAPI /api/* routes.
+const useGradio = !!HF_SPACE_URL;
+
+// ── Axios instance for FastAPI mode ──────────────────────────────────────────
+export const API = `${BACKEND_URL}/api`;
 export const api = axios.create({ baseURL: API, timeout: 180000 });
 
+// ── Gradio API caller ────────────────────────────────────────────────────────
+// Gradio exposes each function as a POST endpoint at /api/<api_name>
+// Request body: { data: [...args] }
+// Response body: { data: [...outputs] }
+async function gradioCall(fnName, ...args) {
+  const url = `${HF_SPACE_URL}/api/${fnName}`;
+  const resp = await axios.post(url, { data: args }, { timeout: 180000 });
+  // Gradio returns { data: [output1, output2, ...] }
+  // Our functions return a single JSON string → parse it
+  const raw = resp.data?.data?.[0];
+  if (typeof raw === "string") {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+
+// ── Unified API adapter ─────────────────────────────────────────────────────
+// Drop-in replacement: every page keeps calling `forgesight.getMetrics()` etc.
+// Under the hood it routes to either FastAPI or Gradio.
+
+export const forgesight = {
+  // GET /api/ → health
+  async health() {
+    if (useGradio) return gradioCall("health");
+    const { data } = await api.get("/");
+    return data;
+  },
+
+  // POST /api/inspections
+  async createInspection({ image_base64, notes, product_spec, source }) {
+    if (useGradio) {
+      return gradioCall("inspect", image_base64, notes || "", product_spec || "", source || "upload");
+    }
+    const { data } = await api.post("/inspections", { image_base64, notes, product_spec, source });
+    return data;
+  },
+
+  // GET /api/inspections
+  async listInspections(limit = 50) {
+    if (useGradio) return gradioCall("list_inspections", limit);
+    const { data } = await api.get("/inspections", { params: { limit } });
+    return data;
+  },
+
+  // GET /api/metrics
+  async getMetrics() {
+    if (useGradio) return gradioCall("metrics");
+    const { data } = await api.get("/metrics");
+    return data;
+  },
+
+  // GET /api/telemetry
+  async getTelemetry() {
+    if (useGradio) return gradioCall("telemetry");
+    const { data } = await api.get("/telemetry");
+    return data;
+  },
+
+  // GET /api/blueprint
+  async getBlueprint() {
+    if (useGradio) return gradioCall("blueprint");
+    const { data } = await api.get("/blueprint");
+    return data;
+  },
+
+  // GET /api/journal
+  async listJournal() {
+    if (useGradio) return gradioCall("journal_list");
+    const { data } = await api.get("/journal");
+    return data;
+  },
+
+  // POST /api/journal
+  async createJournal({ title, body, tags }) {
+    if (useGradio) {
+      // Gradio version takes tags as comma-separated string
+      const tagsStr = Array.isArray(tags) ? tags.join(", ") : tags || "";
+      return gradioCall("journal_create", title, body, tagsStr);
+    }
+    const { data } = await api.post("/journal", { title, body, tags });
+    return data;
+  },
+
+  // POST /api/journal/seed
+  async seedJournal() {
+    if (useGradio) {
+      // Gradio auto-seeds on journal_list; no-op here
+      return { seeded: 0, reason: "auto-seeded via journal_list" };
+    }
+    const { data } = await api.post("/journal/seed");
+    return data;
+  },
+};
+
+// ── Utility ─────────────────────────────────────────────────────────────────
 export const fileToBase64 = (file) =>
   new Promise((resolve, reject) => {
     const reader = new FileReader();

frontend/src/pages/Blueprint.jsx

@@ -1,14 +1,10 @@
 import { useEffect, useState } from "react";
-import { api } from "@/lib/api";
+import { forgesight } from "@/lib/api";
 import { Cpu, HardDrive, Server, BookOpen, Bot, Rocket, ArrowDown } from "lucide-react";
 
 const LAYER_ICONS = {
-  Hardware: Cpu,
-  Runtime: HardDrive,
-  Serving: Server,
-  Model: BookOpen,
-  Agents: Bot,
-  Product: Rocket,
+  Hardware: Cpu, Runtime: HardDrive, Serving: Server,
+  Model: BookOpen, Agents: Bot, Product: Rocket,
 };
 
 const BLUEPRINT_IMG = "https://static.prod-images.emergentagent.com/jobs/d5829a2e-bc03-4880-adcd-73acc809a3bd/images/7251062dc0e36ea4218374b05cc959bc4e6c55a2cf4789a8a2cbc38db6392916.png";
@@ -17,7 +13,7 @@ export default function Blueprint() {
   const [data, setData] = useState(null);
 
   useEffect(() => {
-    api.get("/blueprint").then(({ data }) => setData(data)).catch(() => {});
+    forgesight.getBlueprint().then((d) => setData(d)).catch(() => {});
   }, []);
 
   return (
@@ -40,7 +36,6 @@ export default function Blueprint() {
         </div>
       </header>
 
-      {/* Stack layers */}
       <section className="mb-16">
         <div className="fs-label mb-6">Stack · top to bottom</div>
         <div className="border-l-2 border-[#ED1C24] pl-0">
@@ -75,7 +70,6 @@ export default function Blueprint() {
         </div>
       </section>
 
-      {/* Fine-tune recipe */}
       {data?.finetune_recipe && (
         <section className="border border-white/10 bg-[#141416] p-8 fs-corners" data-testid="finetune-recipe">
           <div className="flex items-end justify-between mb-6 flex-wrap gap-3">
@@ -93,7 +87,6 @@ export default function Blueprint() {
             <Cell k="WALL CLOCK" v={data.finetune_recipe.expected_wall_clock} />
             <Cell k="SERVING" v={data.finetune_recipe.serve_with} />
           </div>
-
           <pre className="mt-8 font-mono text-[12px] leading-relaxed text-zinc-300 bg-[#0A0A0A] border border-white/10 p-5 overflow-x-auto">{`# ForgeSight fine-tune — MI300X + ROCm
 docker run --device=/dev/kfd --device=/dev/dri \\
   --security-opt seccomp=unconfined --group-add video \\

frontend/src/pages/Console.jsx

@@ -1,7 +1,7 @@
 import { useCallback, useRef, useState } from "react";
 import { Upload, Image as ImageIcon, PlayCircle, RotateCcw } from "lucide-react";
 import { toast } from "sonner";
-import { api, fileToBase64 } from "@/lib/api";
+import { forgesight, fileToBase64 } from "@/lib/api";
 import TelemetryWidget from "@/components/TelemetryWidget";
 import AgentTranscript from "@/components/AgentTranscript";
 
@@ -42,7 +42,7 @@ export default function Console() {
     setResult(null);
     try {
       const image_base64 = await fileToBase64(file);
-      const { data } = await api.post("/inspections", {
+      const data = await forgesight.createInspection({
         image_base64,
         notes,
         product_spec: spec,

frontend/src/pages/Feed.jsx

@@ -1,6 +1,6 @@
 import { useEffect, useState } from "react";
 import { Link } from "react-router-dom";
-import { api } from "@/lib/api";
+import { forgesight } from "@/lib/api";
 import { BarChart, Bar, XAxis, YAxis, Tooltip, ResponsiveContainer, Cell } from "recharts";
 import { AlertTriangle, CheckCircle2, XCircle, TrendingUp } from "lucide-react";
 
@@ -10,9 +10,12 @@ export default function Feed() {
 
   const load = async () => {
     try {
-      const [m, l] = await Promise.all([api.get("/metrics"), api.get("/inspections")]);
-      setMetrics(m.data);
-      setItems(l.data.items || []);
+      const [m, l] = await Promise.all([
+        forgesight.getMetrics(),
+        forgesight.listInspections(),
+      ]);
+      setMetrics(m);
+      setItems(l.items || []);
     } catch {}
   };
 

frontend/src/pages/Journal.jsx

@@ -1,5 +1,5 @@
 import { useEffect, useState } from "react";
-import { api } from "@/lib/api";
+import { forgesight } from "@/lib/api";
 import { toast } from "sonner";
 import { Twitter, Linkedin, Copy, Plus, Sparkles } from "lucide-react";
 
@@ -12,12 +12,12 @@ export default function Journal() {
 
   const load = async () => {
     try {
-      const { data } = await api.get("/journal");
+      const data = await forgesight.listJournal();
       setItems(data.items || []);
       if ((data.items || []).length === 0) {
-        await api.post("/journal/seed");
-        const r = await api.get("/journal");
-        setItems(r.data.items || []);
+        await forgesight.seedJournal();
+        const r = await forgesight.listJournal();
+        setItems(r.items || []);
       }
     } catch {}
   };
@@ -33,7 +33,7 @@ export default function Journal() {
     }
     setBusy(true);
     try {
-      const { data } = await api.post("/journal", {
+      const data = await forgesight.createJournal({
         title,
         body,
         tags: tags.split(",").map((t) => t.trim()).filter(Boolean),
@@ -78,41 +78,19 @@ export default function Journal() {
               <span className="fs-label">New milestone</span>
             </div>
             <div className="space-y-3">
-              <input
-                value={title}
-                onChange={(e) => setTitle(e.target.value)}
-                placeholder="Title…"
+              <input value={title} onChange={(e) => setTitle(e.target.value)} placeholder="Title…"
                 className="w-full bg-[#0A0A0A] border border-white/10 focus:border-[#ED1C24] outline-none px-3 py-2 font-mono text-sm"
-                data-testid="journal-title-input"
-              />
-              <textarea
-                value={body}
-                onChange={(e) => setBody(e.target.value)}
-                rows={5}
-                placeholder="What happened today?"
+                data-testid="journal-title-input" />
+              <textarea value={body} onChange={(e) => setBody(e.target.value)} rows={5} placeholder="What happened today?"
                 className="w-full bg-[#0A0A0A] border border-white/10 focus:border-[#ED1C24] outline-none px-3 py-2 font-mono text-sm"
-                data-testid="journal-body-input"
-              />
-              <input
-                value={tags}
-                onChange={(e) => setTags(e.target.value)}
-                placeholder="tags, comma, separated"
+                data-testid="journal-body-input" />
+              <input value={tags} onChange={(e) => setTags(e.target.value)} placeholder="tags, comma, separated"
                 className="w-full bg-[#0A0A0A] border border-white/10 focus:border-[#ED1C24] outline-none px-3 py-2 font-mono text-sm"
-                data-testid="journal-tags-input"
-              />
-              <button
-                disabled={busy}
-                onClick={submit}
+                data-testid="journal-tags-input" />
+              <button disabled={busy} onClick={submit}
                 className="fs-btn fs-btn-primary w-full inline-flex items-center justify-center gap-2 disabled:opacity-50"
-                data-testid="journal-submit-btn"
-              >
-                {busy ? (
-                  <>Generating drafts<span className="fs-cursor" /></>
-                ) : (
-                  <>
-                    <Plus className="w-4 h-4" /> Log + draft posts
-                  </>
-                )}
+                data-testid="journal-submit-btn">
+                {busy ? (<>Generating drafts<span className="fs-cursor" /></>) : (<><Plus className="w-4 h-4" /> Log + draft posts</>)}
               </button>
             </div>
           </div>
@@ -130,32 +108,19 @@ export default function Journal() {
               <div className="flex items-center justify-between mb-3 flex-wrap gap-2">
                 <div className="flex items-center gap-2">
                   <span className="fs-chip fs-chip-fail">{new Date(e.created_at).toLocaleDateString()}</span>
-                  {e.tags?.map((t) => (
-                    <span key={t} className="fs-chip">#{t}</span>
-                  ))}
+                  {e.tags?.map((t) => (<span key={t} className="fs-chip">#{t}</span>))}
                 </div>
               </div>
               <h3 className="font-display font-black tracking-tight text-xl mb-2">{e.title}</h3>
               <p className="text-sm text-zinc-300 leading-relaxed whitespace-pre-line">{e.body}</p>
-
               <div className="grid md:grid-cols-2 gap-3 mt-5">
                 {e.x_post && (
-                  <SocialCard
-                    icon={Twitter}
-                    label="X POST"
-                    text={e.x_post}
-                    onCopy={() => copy(e.x_post, "X post")}
-                    testid={`x-post-${e.id}`}
-                  />
+                  <SocialCard icon={Twitter} label="X POST" text={e.x_post}
+                    onCopy={() => copy(e.x_post, "X post")} testid={`x-post-${e.id}`} />
                 )}
                 {e.linkedin_post && (
-                  <SocialCard
-                    icon={Linkedin}
-                    label="LINKEDIN POST"
-                    text={e.linkedin_post}
-                    onCopy={() => copy(e.linkedin_post, "LinkedIn post")}
-                    testid={`li-post-${e.id}`}
-                  />
+                  <SocialCard icon={Linkedin} label="LINKEDIN POST" text={e.linkedin_post}
+                    onCopy={() => copy(e.linkedin_post, "LinkedIn post")} testid={`li-post-${e.id}`} />
                 )}
               </div>
             </article>
@@ -174,10 +139,7 @@ function SocialCard({ icon: Icon, label, text, onCopy, testid }) {
           <Icon className="w-3.5 h-3.5 text-[#ED1C24]" />
           <span className="fs-label">{label}</span>
         </div>
-        <button
-          onClick={onCopy}
-          className="fs-chip hover:text-white hover:border-white/40 inline-flex items-center gap-1"
-        >
+        <button onClick={onCopy} className="fs-chip hover:text-white hover:border-white/40 inline-flex items-center gap-1">
           <Copy className="w-3 h-3" /> copy
         </button>
       </div>

hf_space/README.md

@@ -0,0 +1,47 @@
+---
+title: ForgeSight
+emoji: 🔍
+colorFrom: red
+colorTo: gray
+sdk: gradio
+sdk_version: 5.29.1
+app_file: app.py
+pinned: true
+license: mit
+short_description: "Multimodal QC Copilot on AMD MI300X + ROCm"
+tags:
+  - amd
+  - rocm
+  - mi300x
+  - qwen
+  - vllm
+  - quality-control
+  - agents
+---
+
+# 🔍 ForgeSight — Multimodal Quality-Control Copilot
+
+ForgeSight ships a **4-agent pipeline** that inspects assembly-line images,
+diagnoses root cause, drafts work orders, and publishes reports — fine-tuned
+on **Qwen2-VL** and served on **AMD Instinct MI300X** via ROCm + vLLM.
+
+## Architecture
+
+```text
+React Frontend → HF Spaces (Gradio API) → AMD MI300X vLLM (agents.py)
+```
+
+### Agents
+
+1. **Inspector** — Vision analysis, defect detection
+2. **Diagnostician** — Root-cause analysis
+3. **Action** — Work order generation
+4. **Reporter** — Human-readable summary
+
+## Hackathon Tracks
+
+- **Track 1**: Agentic AI on AMD
+- **Track 2**: Fine-tuning with Optimum-AMD
+- **Track 3**: Multimodal vision (Qwen2-VL)
+
+Built for the AMD + lablab Hackathon.

hf_space/agents.py

@@ -0,0 +1,293 @@
+"""
+ForgeSight multi-agent quality-control pipeline.
+Agents call the fine-tuned model served by vLLM on AMD Instinct MI300X.
+Falls back to mock responses if the AMD inference server is unreachable.
+"""
+import os
+import json
+import uuid
+import re
+import asyncio
+from typing import Optional, List, Dict, Any
+
+import httpx  # async HTTP — lightweight, no extra deps beyond requirements
+
+# ── AMD vLLM inference endpoint ─────────────────────────────────────────────
+# vLLM exposes an OpenAI-compatible API at /v1/chat/completions.
+# Set AMD_INFERENCE_URL in your .env to point at the running vLLM server.
+# Example: http://129.212.191.163:8000   (direct port — ensure firewall allows it)
+# Or use the Jupyter proxy route: http://129.212.191.163/proxy/8000
+AMD_INFERENCE_URL = os.environ.get(
+    "AMD_INFERENCE_URL",
+    "http://129.212.191.163:8000"
+).rstrip("/")
+
+# The model name vLLM is serving (used in the chat/completions request).
+# Override with AMD_MODEL_NAME env var if you deploy a different checkpoint.
+AMD_MODEL_NAME = os.environ.get("AMD_MODEL_NAME", "Qwen/Qwen2-VL-7B-Instruct")
+
+# Timeout (seconds) to wait for the AMD server before falling back to mock.
+AMD_TIMEOUT = float(os.environ.get("AMD_TIMEOUT", "30"))
+
+# ── System prompts ───────────────────────────────────────────────────────────
+INSPECTOR_SYSTEM = """You are the INSPECTOR agent of ForgeSight — a multimodal quality-control copilot
+running on AMD Instinct MI300X + ROCm. Your job: analyze the submitted product/assembly-line
+image and surface visible defects, anomalies, or violations.
+
+Return ONLY compact JSON with this exact shape (no prose, no code fences):
+{
+  "verdict": "pass" | "warn" | "fail",
+  "confidence": 0.0-1.0,
+  "defects": [
+    {"type": "short category e.g. surface-scratch", "severity": "low|medium|high", "location": "short spatial description", "description": "one sentence"}
+  ],
+  "observation": "2-3 sentence plain-english summary of what you see"
+}
+Be precise. If the image shows no manufacturing artifact at all, still describe what is visible
+and mark verdict "warn" with a defect explaining the mismatch."""
+
+
+DIAGNOSTICIAN_SYSTEM = """You are the DIAGNOSTICIAN agent of ForgeSight. Given the INSPECTOR's
+JSON report and user notes, produce a probable root-cause analysis.
+
+Return ONLY compact JSON:
+{
+  "probable_cause": "one-sentence most likely cause",
+  "contributing_factors": ["factor 1", "factor 2", "factor 3"],
+  "affected_process_step": "e.g. CNC milling, injection cooling, weld pass 2"
+}
+Be concrete and industry-literate."""
+
+
+ACTION_SYSTEM = """You are the ACTION agent of ForgeSight. Given the INSPECTOR and DIAGNOSTICIAN
+outputs, draft an actionable work order.
+
+Return ONLY compact JSON:
+{
+  "priority": "P0|P1|P2|P3",
+  "assignee_role": "e.g. line-lead, maintenance-tech, quality-engineer",
+  "steps": ["step 1", "step 2", "step 3"],
+  "estimated_minutes": integer,
+  "parts_or_tools": ["item 1", "item 2"]
+}"""
+
+
+REPORTER_SYSTEM = """You are the REPORTER agent of ForgeSight. Compile a final human-readable
+summary of the full inspection in <=70 words. Return ONLY JSON:
+{
+  "headline": "<=10 word title",
+  "summary": "<=70 word paragraph",
+  "tags": ["tag1", "tag2", "tag3"]
+}"""
+
+SOCIAL_SYSTEM = """You craft punchy Build-in-Public social posts for a hackathon project named
+"ForgeSight" — a multimodal agentic quality-control copilot running on AMD Instinct MI300X + ROCm.
+Always include hashtags: #AMDHackathon #ROCm #AIatAMD #lablab and mention @AIatAMD and @lablab.
+Return ONLY JSON:
+{"x_post": "<=260 chars, punchy, 1-2 emojis ok", "linkedin_post": "<=600 chars, narrative, 3 short paragraphs"}"""
+
+
+# ── JSON extraction ──────────────────────────────────────────────────────────
+def _extract_json(raw: str) -> Dict[str, Any]:
+    """Best-effort JSON extraction from an LLM response."""
+    if not raw:
+        return {}
+    cleaned = re.sub(r"^```(?:json)?\s*|\s*```$", "", raw.strip(), flags=re.MULTILINE)
+    try:
+        return json.loads(cleaned)
+    except Exception:
+        pass
+    match = re.search(r"\{[\s\S]*\}", cleaned)
+    if match:
+        try:
+            return json.loads(match.group(0))
+        except Exception:
+            pass
+    return {"_raw": raw}
+
+
+# ── Mock fallbacks ───────────────────────────────────────────────────────────
+def _mock_response(name: str) -> Dict[str, Any]:
+    """Fallback mock responses when AMD server is unreachable."""
+    mocks = {
+        "inspector": {
+            "verdict": "warn", "confidence": 0.85,
+            "defects": [{"type": "surface-scratch", "severity": "low",
+                         "location": "top-left edge", "description": "Minor scratch visible"}],
+            "observation": "Minor scratch detected on surface. [LOCAL MOCK — AMD server offline]"
+        },
+        "diagnostician": {
+            "probable_cause": "Improper handling during milling. [LOCAL MOCK]",
+            "contributing_factors": ["Machine calibration", "Operator error"],
+            "affected_process_step": "CNC milling"
+        },
+        "action": {
+            "priority": "P2", "assignee_role": "quality-engineer",
+            "steps": ["Inspect machine", "Recalibrate"],
+            "estimated_minutes": 30, "parts_or_tools": ["Calibration kit"]
+        },
+        "reporter": {
+            "headline": "Minor Scratch Detected [Mock]",
+            "summary": "Local mock response — start the AMD vLLM server to use the fine-tuned model.",
+            "tags": ["scratch", "mock", "local"]
+        },
+        "social": {
+            "x_post": "Testing our pipeline #AMDHackathon",
+            "linkedin_post": "We are testing our pipeline today..."
+        },
+    }
+    parsed = mocks.get(name, {})
+    return {"raw": json.dumps(parsed), "parsed": parsed, "source": "mock (AMD server offline)"}
+
+
+# ── AMD vLLM call (OpenAI-compatible /v1/chat/completions) ───────────────────
+async def _call_amd_vllm(
+    system_prompt: str,
+    user_text: str,
+    image_base64: Optional[str] = None,
+) -> Optional[str]:
+    """
+    Call the vLLM server on the AMD MI300X using its OpenAI-compatible API.
+    Supports vision models (image_base64) and text-only calls.
+    Returns the assistant message text, or None if the server is unreachable.
+    """
+    # Build messages array
+    if image_base64:
+        # Multimodal message with base64 image
+        user_content = [
+            {
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:image/jpeg;base64,{image_base64}"
+                }
+            },
+            {
+                "type": "text",
+                "text": user_text
+            }
+        ]
+    else:
+        user_content = user_text
+
+    payload = {
+        "model": AMD_MODEL_NAME,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_content},
+        ],
+        "max_tokens": 1024,
+        "temperature": 0.1,  # Low temperature for deterministic structured output
+    }
+
+    url = f"{AMD_INFERENCE_URL}/v1/chat/completions"
+
+    try:
+        async with httpx.AsyncClient(timeout=AMD_TIMEOUT) as client:
+            resp = await client.post(url, json=payload)
+            resp.raise_for_status()
+            data = resp.json()
+            return data["choices"][0]["message"]["content"]
+    except httpx.ConnectError:
+        return None  # Server not reachable → use mock
+    except httpx.TimeoutException:
+        return None  # Server too slow → use mock
+    except Exception:
+        return None  # Any other error → use mock
+
+
+# ── Agent runner ─────────────────────────────────────────────────────────────
+async def _run_agent(
+    name: str,
+    system_message: str,
+    user_text: str,
+    image_base64: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Run a single agent. Tries AMD MI300X vLLM first, falls back to mock.
+    """
+    raw_text = await _call_amd_vllm(system_message, user_text, image_base64)
+
+    if raw_text is None:
+        # AMD server not reachable — use local mock (safe for dev/demo)
+        result = _mock_response(name)
+        return result
+
+    # AMD server responded — parse its JSON output
+    parsed = _extract_json(raw_text)
+    return {
+        "raw": raw_text,
+        "parsed": parsed,
+        "source": f"AMD MI300X vLLM @ {AMD_INFERENCE_URL} ({AMD_MODEL_NAME})"
+    }
+
+
+# ── Public pipeline ──────────────────────────────────────────────────────────
+async def run_pipeline(
+    image_base64: str,
+    notes: str = "",
+    product_spec: str = "",
+) -> Dict[str, Any]:
+    """
+    Run the 4-agent pipeline sequentially and return the full transcript.
+    """
+    context = f"Operator notes: {notes or '(none)'}\nProduct spec: {product_spec or '(generic)'}"
+
+    # 1) Inspector (vision — passes image to vLLM)
+    inspector = await _run_agent(
+        "inspector",
+        INSPECTOR_SYSTEM,
+        f"Inspect this image for manufacturing defects.\n{context}",
+        image_base64=image_base64,
+    )
+
+    # 2) Diagnostician (text only)
+    diagnostician = await _run_agent(
+        "diagnostician",
+        DIAGNOSTICIAN_SYSTEM,
+        f"INSPECTOR_REPORT:\n{json.dumps(inspector['parsed'])}\n\n{context}",
+    )
+
+    # 3) Action (text only)
+    action = await _run_agent(
+        "action",
+        ACTION_SYSTEM,
+        (
+            f"INSPECTOR_REPORT:\n{json.dumps(inspector['parsed'])}\n\n"
+            f"DIAGNOSTICIAN_REPORT:\n{json.dumps(diagnostician['parsed'])}"
+        ),
+    )
+
+    # 4) Reporter (text only)
+    reporter = await _run_agent(
+        "reporter",
+        REPORTER_SYSTEM,
+        (
+            f"INSPECTOR_REPORT:\n{json.dumps(inspector['parsed'])}\n\n"
+            f"DIAGNOSTICIAN_REPORT:\n{json.dumps(diagnostician['parsed'])}\n\n"
+            f"ACTION_REPORT:\n{json.dumps(action['parsed'])}"
+        ),
+    )
+
+    model_label = AMD_MODEL_NAME
+    return {
+        "agents": [
+            {"role": "inspector",     "label": "Inspector Agent",     "model": model_label, "output": inspector},
+            {"role": "diagnostician", "label": "Diagnostician Agent", "model": model_label, "output": diagnostician},
+            {"role": "action",        "label": "Action Agent",        "model": model_label, "output": action},
+            {"role": "reporter",      "label": "Reporter Agent",      "model": model_label, "output": reporter},
+        ],
+    }
+
+
+async def generate_social_post(milestone_title: str, milestone_body: str) -> Dict[str, str]:
+    """Generate X + LinkedIn social post drafts for a build-in-public milestone."""
+    result = await _run_agent(
+        "social",
+        SOCIAL_SYSTEM,
+        f"Milestone: {milestone_title}\n\nDetails: {milestone_body}",
+    )
+    parsed = result["parsed"]
+    return {
+        "x_post": parsed.get("x_post", result["raw"][:260]),
+        "linkedin_post": parsed.get("linkedin_post", result["raw"][:600]),
+    }

hf_space/app.py

@@ -0,0 +1,373 @@
+"""
+ForgeSight — Hugging Face Spaces Gradio backend.
+Wraps the multi-agent pipeline so the React frontend can call it
+via the Gradio Client JS SDK or plain HTTP POST to /api/<fn_name>.
+
+Deploy: push this repo to a HF Space (Gradio SDK).
+"""
+import os
+import json
+import math
+import time
+import uuid
+import gradio as gr
+from datetime import datetime, timezone
+
+# ── Import the agent pipeline ───────────────────────────────────────────────
+from agents import run_pipeline, generate_social_post
+
+# ── In-memory store (HF Spaces has no persistent DB) ────────────────────────
+# For a real deployment, swap with MongoDB or a HF Dataset-backed store.
+_inspections: list = []
+_journal: list = []
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+# ── 1. Inspection endpoint ──────────────────────────────────────────────────
+async def inspect(image_base64: str, notes: str = "", product_spec: str = "", source: str = "upload"):
+    """Run the 4-agent inspection pipeline on a base64 image."""
+    # Strip potential data-URI prefix
+    if "," in image_base64 and image_base64.strip().startswith("data:"):
+        image_base64 = image_base64.split(",", 1)[1]
+
+    transcript = await run_pipeline(
+        image_base64=image_base64,
+        notes=notes or "",
+        product_spec=product_spec or "",
+    )
+
+    inspection = {
+        "id": str(uuid.uuid4()),
+        "created_at": _now_iso(),
+        "notes": notes or "",
+        "product_spec": product_spec or "",
+        "source": source or "upload",
+        "transcript": transcript,
+    }
+    _inspections.insert(0, inspection)
+
+    summary = _summarize(inspection)
+    return json.dumps({
+        "id": inspection["id"],
+        "created_at": inspection["created_at"],
+        "transcript": transcript,
+        "summary": summary,
+    })
+
+
+# ── 2. List inspections ─────────────────────────────────────────────────────
+async def list_inspections(limit: int = 50):
+    items = [_summarize(doc) for doc in _inspections[:limit]]
+    return json.dumps({"items": items, "total": len(items)})
+
+
+# ── 3. Metrics ───────────────────────────────────────────────────────────────
+async def metrics():
+    total = len(_inspections)
+    verdict_counts = {"pass": 0, "warn": 0, "fail": 0}
+    defect_type_counts = {}
+    confidences = []
+
+    for doc in _inspections:
+        summary = _summarize(doc)
+        v = summary["verdict"] if summary["verdict"] in verdict_counts else "warn"
+        verdict_counts[v] += 1
+        confidences.append(summary["confidence"])
+        agents = doc.get("transcript", {}).get("agents", [])
+        inspector = next((a for a in agents if a["role"] == "inspector"), None)
+        defects = ((inspector or {}).get("output", {}).get("parsed", {}) or {}).get("defects") or []
+        if isinstance(defects, list):
+            for d in defects:
+                if isinstance(d, dict):
+                    t = (d.get("type") or "unknown").lower()
+                    defect_type_counts[t] = defect_type_counts.get(t, 0) + 1
+
+    avg_conf = sum(confidences) / len(confidences) if confidences else 0.0
+    top_defects = sorted(defect_type_counts.items(), key=lambda x: x[1], reverse=True)[:6]
+    quality_score = 0
+    if total > 0:
+        quality_score = round(100 * (verdict_counts["pass"] + 0.5 * verdict_counts["warn"]) / total)
+
+    return json.dumps({
+        "total_inspections": total,
+        "verdict_counts": verdict_counts,
+        "avg_confidence": round(avg_conf, 3),
+        "top_defects": [{"type": t, "count": c} for t, c in top_defects],
+        "quality_score": quality_score,
+    })
+
+
+# ── 4. Telemetry (simulated MI300X) ─────────────────────────────────────────
+async def telemetry():
+    t = time.time()
+    gpu_util = 62 + 30 * math.sin(t / 4.0)
+    vram_used = 88 + 20 * math.sin(t / 7.0)
+    tokens_per_sec = 2850 + 450 * math.sin(t / 3.0)
+    power_w = 620 + 80 * math.sin(t / 5.0)
+    temp_c = 58 + 7 * math.sin(t / 6.0)
+    return json.dumps({
+        "simulated": True,
+        "device": "AMD Instinct MI300X",
+        "gpu_util_pct": round(max(0, min(100, gpu_util)), 1),
+        "vram_used_gb": round(max(0, vram_used), 1),
+        "vram_total_gb": 192.0,
+        "tokens_per_sec": int(max(0, tokens_per_sec)),
+        "power_watts": int(max(0, power_w)),
+        "temp_c": round(max(0, temp_c), 1),
+        "ts": _now_iso(),
+    })
+
+
+# ── 5. Blueprint ─────���──────────────────────────────────────────────────────
+async def blueprint():
+    return json.dumps({
+        "stack": [
+            {
+                "layer": "Hardware",
+                "title": "AMD Instinct MI300X",
+                "detail": "192 GB HBM3 · 5.3 TB/s memory bandwidth · 8× GPU node",
+                "why": "Massive VRAM enables serving 70B-class Qwen-VL models without sharding.",
+            },
+            {
+                "layer": "Runtime",
+                "title": "ROCm 6.2",
+                "detail": "Open compute runtime · HIP · MIOpen · RCCL",
+                "why": "PyTorch + vLLM run natively on MI300X via ROCm.",
+            },
+            {
+                "layer": "Serving",
+                "title": "vLLM on ROCm",
+                "detail": "PagedAttention · continuous batching · OpenAI-compatible API",
+                "why": "High-throughput multimodal inference for the agent pipeline.",
+            },
+            {
+                "layer": "Model",
+                "title": "Qwen2-VL-72B (fine-tuned)",
+                "detail": "LoRA fine-tune on defect-image + work-order pairs via Optimum-AMD",
+                "why": "Domain-specialized vision reasoning beats zero-shot generic VLMs.",
+            },
+            {
+                "layer": "Agents",
+                "title": "Inspector → Diagnostician → Action → Reporter",
+                "detail": "Sequential multi-agent with structured JSON hand-offs",
+                "why": "Interpretable, auditable pipeline for industrial QC.",
+            },
+            {
+                "layer": "Product",
+                "title": "ForgeSight Console",
+                "detail": "React + FastAPI · live transcript · defect feed · build journal",
+                "why": "End-to-end demonstrable app shipped for the hackathon.",
+            },
+        ],
+        "finetune_recipe": {
+            "base_model": "Qwen/Qwen2-VL-72B-Instruct",
+            "dataset": "ForgeSight-QC-10K (proprietary defect-image ↔ work-order pairs)",
+            "method": "QLoRA r=64 · Optimum-AMD · bf16",
+            "hardware": "1× MI300X node (8 GPUs)",
+            "expected_wall_clock": "~6h for 3 epochs on 10K pairs",
+            "serve_with": "vLLM 0.6+ on ROCm",
+        },
+    })
+
+
+# ── 6. Journal ──────────────────────────────────────────────────────────────
+async def journal_list():
+    # Auto-seed if empty
+    if not _journal:
+        await _seed_journal()
+    return json.dumps({"items": _journal, "total": len(_journal)})
+
+
+async def journal_create(title: str, body: str, tags: str = ""):
+    tag_list = [t.strip() for t in tags.split(",") if t.strip()] if tags else []
+    try:
+        social = await generate_social_post(title, body)
+    except Exception:
+        social = {"x_post": "", "linkedin_post": ""}
+
+    entry = {
+        "id": str(uuid.uuid4()),
+        "created_at": _now_iso(),
+        "title": title,
+        "body": body,
+        "tags": tag_list,
+        "x_post": social.get("x_post", ""),
+        "linkedin_post": social.get("linkedin_post", ""),
+    }
+    _journal.insert(0, entry)
+    return json.dumps(entry)
+
+
+async def _seed_journal():
+    seeds = [
+        {
+            "title": "Kickoff: ForgeSight on AMD Developer Cloud",
+            "body": "Spun up an MI300X instance on AMD Developer Cloud. First impression: zero CUDA-lock-in, ROCm + PyTorch just worked. Targeting all three hackathon tracks with one agentic multimodal QC copilot.",
+            "tags": ["kickoff", "amd", "rocm"],
+        },
+        {
+            "title": "Multi-agent pipeline wired end-to-end",
+            "body": "Inspector → Diagnostician → Action → Reporter. Each agent produces strict JSON so hand-offs stay auditable. Running on Claude Sonnet 4.5 today, swapping to Qwen2-VL on MI300X next.",
+            "tags": ["agents", "pipeline", "qwen"],
+        },
+        {
+            "title": "Fine-tune recipe: QLoRA on Qwen2-VL with Optimum-AMD",
+            "body": "Drafted the LoRA fine-tune path for 10K defect-image ↔ work-order pairs. Expecting ~6h wall-clock on a single MI300X node. vLLM-ROCm will serve the result.",
+            "tags": ["fine-tuning", "qlora", "optimum-amd"],
+        },
+    ]
+    for s in seeds:
+        try:
+            social = await generate_social_post(s["title"], s["body"])
+        except Exception:
+            social = {"x_post": "", "linkedin_post": ""}
+        _journal.insert(0, {
+            "id": str(uuid.uuid4()),
+            "created_at": _now_iso(),
+            **s,
+            "x_post": social.get("x_post", ""),
+            "linkedin_post": social.get("linkedin_post", ""),
+        })
+
+
+# ── Helpers ──────────────────────────────────────────────────────────────────
+def _summarize(inspection: dict) -> dict:
+    agents = inspection.get("transcript", {}).get("agents", [])
+    inspector = next((a for a in agents if a["role"] == "inspector"), None)
+    reporter = next((a for a in agents if a["role"] == "reporter"), None)
+    action = next((a for a in agents if a["role"] == "action"), None)
+
+    inspector_out = (inspector or {}).get("output", {}).get("parsed", {}) or {}
+    reporter_out = (reporter or {}).get("output", {}).get("parsed", {}) or {}
+    action_out = (action or {}).get("output", {}).get("parsed", {}) or {}
+
+    defects = inspector_out.get("defects") or []
+    return {
+        "id": inspection["id"],
+        "created_at": inspection["created_at"],
+        "verdict": inspector_out.get("verdict", "warn"),
+        "confidence": float(inspector_out.get("confidence", 0.0) or 0.0),
+        "headline": reporter_out.get("headline") or inspector_out.get("observation", "Inspection complete")[:60],
+        "defect_count": len(defects) if isinstance(defects, list) else 0,
+        "priority": action_out.get("priority", "P2"),
+        "source": inspection.get("source", "upload"),
+    }
+
+
+# ── Health / root check ─────────────────────────────────────────────────────
+async def health():
+    return json.dumps({
+        "service": "forgesight",
+        "status": "online",
+        "track": "AMD Hackathon — Tracks 1+2+3",
+        "runtime": "Hugging Face Spaces (Gradio)",
+    })
+
+
+# ── Build the Gradio app ────────────────────────────────────────────────────
+# Each gr.Interface becomes a named API endpoint at /api/<fn_name>
+# The React frontend calls these via fetch() to the HF Space URL.
+
+with gr.Blocks(title="ForgeSight — AMD MI300X QC Copilot") as demo:
+    gr.Markdown("# 🔍 ForgeSight — Multimodal QC Copilot")
+    gr.Markdown("Backend API for the ForgeSight React frontend. Powered by AMD Instinct MI300X + ROCm.")
+
+    # --- API-only endpoints (hidden UI, exposed as /api/...) ---
+
+    # Health check
+    health_btn = gr.Button("Health Check", visible=False)
+    health_out = gr.Textbox(visible=False)
+    health_btn.click(fn=health, inputs=[], outputs=health_out, api_name="health")
+
+    # Inspect
+    inspect_img = gr.Textbox(visible=False)
+    inspect_notes = gr.Textbox(visible=False)
+    inspect_spec = gr.Textbox(visible=False)
+    inspect_source = gr.Textbox(visible=False)
+    inspect_out = gr.Textbox(visible=False)
+    inspect_btn = gr.Button("Inspect", visible=False)
+    inspect_btn.click(
+        fn=inspect,
+        inputs=[inspect_img, inspect_notes, inspect_spec, inspect_source],
+        outputs=inspect_out,
+        api_name="inspect",
+    )
+
+    # List inspections
+    list_limit = gr.Number(visible=False, value=50)
+    list_out = gr.Textbox(visible=False)
+    list_btn = gr.Button("List", visible=False)
+    list_btn.click(fn=list_inspections, inputs=[list_limit], outputs=list_out, api_name="list_inspections")
+
+    # Metrics
+    metrics_out = gr.Textbox(visible=False)
+    metrics_btn = gr.Button("Metrics", visible=False)
+    metrics_btn.click(fn=metrics, inputs=[], outputs=metrics_out, api_name="metrics")
+
+    # Telemetry
+    telem_out = gr.Textbox(visible=False)
+    telem_btn = gr.Button("Telemetry", visible=False)
+    telem_btn.click(fn=telemetry, inputs=[], outputs=telem_out, api_name="telemetry")
+
+    # Blueprint
+    bp_out = gr.Textbox(visible=False)
+    bp_btn = gr.Button("Blueprint", visible=False)
+    bp_btn.click(fn=blueprint, inputs=[], outputs=bp_out, api_name="blueprint")
+
+    # Journal list
+    jl_out = gr.Textbox(visible=False)
+    jl_btn = gr.Button("Journal List", visible=False)
+    jl_btn.click(fn=journal_list, inputs=[], outputs=jl_out, api_name="journal_list")
+
+    # Journal create
+    jc_title = gr.Textbox(visible=False)
+    jc_body = gr.Textbox(visible=False)
+    jc_tags = gr.Textbox(visible=False)
+    jc_out = gr.Textbox(visible=False)
+    jc_btn = gr.Button("Journal Create", visible=False)
+    jc_btn.click(
+        fn=journal_create,
+        inputs=[jc_title, jc_body, jc_tags],
+        outputs=jc_out,
+        api_name="journal_create",
+    )
+
+    # --- Visible demo UI for HF Space visitors ---
+    with gr.Tab("🔬 Quick Inspect"):
+        gr.Markdown("Upload an image to run the 4-agent QC pipeline.")
+        with gr.Row():
+            with gr.Column():
+                demo_img = gr.Image(type="filepath", label="Product Image")
+                demo_notes = gr.Textbox(label="Operator Notes", placeholder="e.g. batch B-124, shift 2")
+                demo_spec = gr.Textbox(label="Product Spec", placeholder="e.g. aluminum 6061 bracket")
+                demo_run = gr.Button("🚀 Run Inspection", variant="primary")
+            with gr.Column():
+                demo_result = gr.JSON(label="Pipeline Result")
+
+        async def demo_inspect(img_path, notes, spec):
+            if not img_path:
+                return {"error": "Please upload an image"}
+            import base64
+            with open(img_path, "rb") as f:
+                b64 = base64.b64encode(f.read()).decode()
+            raw = await inspect(b64, notes or "", spec or "", "upload")
+            return json.loads(raw)
+
+        demo_run.click(fn=demo_inspect, inputs=[demo_img, demo_notes, demo_spec], outputs=demo_result)
+
+    with gr.Tab("📊 Status"):
+        gr.Markdown("### Service Status")
+        status_btn = gr.Button("Check Status")
+        status_out = gr.JSON()
+        async def check_status():
+            h = json.loads(await health())
+            m = json.loads(await metrics())
+            return {**h, **m}
+        status_btn.click(fn=check_status, inputs=[], outputs=status_out)
+
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

hf_space/deploy.ps1

@@ -0,0 +1,17 @@
+# Deploy ForgeSight to Hugging Face Spaces
+# Run this from the project root: c:\Users\user\OneDrive\Desktop\hans\hans
+
+# 1. Clone the HF Space repo (if not already done)
+git clone https://huggingface.co/spaces/rasAli02/ForgeSight hf_space_repo
+
+# 2. Copy all deployment files into the cloned repo
+Copy-Item hf_space\* hf_space_repo\ -Force
+
+# 3. Push to HF Spaces
+Set-Location hf_space_repo
+git add -A
+git commit -m "Deploy ForgeSight Gradio backend with AMD MI300X agent pipeline"
+git push
+
+# After push, the space will build and start at:
+# https://rasali02-forgesight.hf.space

hf_space/requirements.txt

@@ -0,0 +1,3 @@
+gradio>=5.0.0
+httpx>=0.27.0
+python-dotenv>=1.0.1

hf_space_repo

@@ -0,0 +1 @@
+Subproject commit fc45d46feb8d919eebc696edd5effd2295dbda13