Add MiniCPM5 local parser and multi-trip planner

FIELD_NOTES.md

@@ -0,0 +1,52 @@
+# Field Notes: Tiny Dispatch Coach
+
+## What changed after the first prototype
+
+The first version was a normal route optimizer wrapped in Gradio. That was not
+enough for Build Small. The useful part of the product is not only route math;
+it is turning messy human dispatch notes into constraints that a planner can
+actually verify.
+
+The current design uses OpenBMB MiniCPM5-1B-GGUF as the small local model for
+constraint parsing. The deterministic optimizer then plans routes with capacity,
+time windows, waiting time, lateness, and a manual baseline comparison.
+
+## Why MiniCPM5-1B
+
+- It is an OpenBMB model, matching the hackathon sponsor category.
+- It is 1.08B parameters, far below the 32B rule.
+- The GGUF release can run locally through llama.cpp.
+- Its model card highlights local deployment, tool use, long context, and
+  compact agent workflows, which fit this route-coaching task.
+
+## What the model does
+
+MiniCPM5 receives dispatcher notes such as:
+
+```text
+Start at 8:00. School and clinic stops are urgent. Fresh produce should be
+delivered before lunch. Van capacity 18.
+```
+
+It returns a compact JSON constraint object:
+
+```json
+{
+  "prefer_early_priority": true,
+  "avoid_late_penalty": 2.0,
+  "max_route_load": 18,
+  "depot_start": 480,
+  "soft_due_before": 720,
+  "boost_terms": ["school", "fresh"]
+}
+```
+
+The planner treats those constraints as inputs. It does not let the language
+model invent routes or metrics.
+
+## Privacy stance
+
+The demo data is synthetic. The app stores nothing, uses no cloud LLM API, and
+does not require user secrets. Uploaded CSVs are processed only during the
+Gradio session.
+

README.md

@@ -13,24 +13,57 @@ tags:
   - gradio
   - hackathon
   - small-models
+  - minicpm
+  - openbmb
   - operations-research
   - logistics
 ---
 
 # Tiny Dispatch Coach
 
-Tiny Dispatch Coach is a Backyard AI project for small delivery teams.
+Tiny Dispatch Coach is a Backyard AI project for small delivery teams. It uses
+OpenBMB `MiniCPM5-1B-GGUF` as the local small model for dispatch-note parsing,
+then hands the structured constraints to a deterministic route planner.
 
 It converts a daily order sheet and messy dispatcher notes into:
 
-- structured delivery constraints,
+- structured delivery constraints parsed from messy human notes,
 - route plans with time-window and capacity checks,
 - before/after metrics against a manual baseline,
 - driver-ready route cards,
 - a simple visual route map.
 
 The app is designed for the Build Small Hackathon rule set: Gradio, Hugging Face
-Spaces, and models under 32B parameters. The first public version ships with a
-deterministic offline planner so the demo is usable without cloud APIs. During
-the hack window, the natural-language constraint parser can be swapped to a
-local small model backend such as MiniCPM or Llama via llama.cpp.
+Spaces, and models under 32B parameters.
+
+## Model
+
+- Model repo: `openbmb/MiniCPM5-1B-GGUF`
+- File: `MiniCPM5-1B-Q4_K_M.gguf`
+- Parameter count: `1.08B`
+- Runtime target: local GGUF through `llama-cpp-python`
+- Cloud LLM APIs: none
+
+If the local model runtime is unavailable during a cold start, the app falls
+back to a deterministic parser and makes that visible in the parser trace. The
+route optimizer never depends on hidden model output: every route, time window,
+lateness minute, and baseline delta is computed deterministically.
+
+## Current Scope
+
+Included now:
+
+- MiniCPM5 text constraint parsing.
+- Capacity-safe multi-trip route planning.
+- Manual baseline comparison.
+- Synthetic sample data only.
+- Field notes and a shareable model/planner trace.
+
+Planned after the core demo is stable:
+
+- Optional image intake with MiniCPM-V 4.6 for order-sheet OCR.
+- Optional deeper reporting with MiniCPM4.1-8B if Space resources allow it.
+
+Not included:
+
+- VoxCPM2 or voice/TTS features.

agent_trace.json

@@ -0,0 +1,32 @@
+{
+  "project": "Tiny Dispatch Coach",
+  "model": {
+    "repo": "openbmb/MiniCPM5-1B-GGUF",
+    "file": "MiniCPM5-1B-Q4_K_M.gguf",
+    "parameters": "1.08B",
+    "runtime": "llama.cpp via llama-cpp-python"
+  },
+  "trace": [
+    {
+      "step": "parse_dispatch_notes",
+      "input": "Start at 8:00. School and clinic stops are urgent. Fresh produce should be delivered before lunch. Van capacity 18.",
+      "expected_json": {
+        "prefer_early_priority": true,
+        "avoid_late_penalty": 2.0,
+        "max_route_load": 18,
+        "depot_start": 480,
+        "soft_due_before": 720,
+        "boost_terms": ["school", "fresh"]
+      }
+    },
+    {
+      "step": "deterministic_planner",
+      "policy": "Minimize late minutes first, then late stops, then distance. Split into capacity-safe trips when needed."
+    },
+    {
+      "step": "explain_results",
+      "policy": "Show route cards, time windows, waiting time, lateness, and manual-baseline deltas."
+    }
+  ],
+  "privacy": "Synthetic sample data only. No API keys, personal email, customer records, or company data are stored in this artifact."
+}

app.py

@@ -1,8 +1,11 @@
-import csv
-import io
+import json
 import math
+import os
 import re
-from dataclasses import dataclass, replace
+from dataclasses import dataclass
+from functools import lru_cache
+from html import escape
+from itertools import permutations
 from pathlib import Path
 from typing import Dict, Iterable, List, Optional, Tuple
 
@@ -20,6 +23,9 @@ SAMPLE_PATH = Path(__file__).with_name("sample_orders.csv")
 AVG_SPEED_KMPH = 22.0
 CAPACITY = 18
 START_MINUTE = 8 * 60
+MINICPM_REPO = "openbmb/MiniCPM5-1B-GGUF"
+MINICPM_FILE = "MiniCPM5-1B-Q4_K_M.gguf"
+MINICPM_PARAMS = "1.08B"
 
 
 @dataclass(frozen=True)
@@ -40,6 +46,7 @@ class Stop:
 @dataclass(frozen=True)
 class PlanStop:
     stop: Stop
+    route_id: int
     arrival: int
     start: int
     depart: int
@@ -159,6 +166,96 @@ def parse_dispatch_notes(notes: str) -> Dict[str, object]:
     return constraints
 
 
+def normalize_constraints(raw: Dict[str, object]) -> Dict[str, object]:
+    constraints = {
+        "prefer_early_priority": bool(raw.get("prefer_early_priority", True)),
+        "avoid_late_penalty": float(raw.get("avoid_late_penalty", 2.0) or 2.0),
+        "max_route_load": int(raw.get("max_route_load", CAPACITY) or CAPACITY),
+        "depot_start": int(raw.get("depot_start", START_MINUTE) or START_MINUTE),
+        "boost_terms": list(raw.get("boost_terms", []) or []),
+        "source": raw.get("source", "rule-fallback"),
+    }
+    if raw.get("soft_due_before") is not None:
+        constraints["soft_due_before"] = int(raw["soft_due_before"])
+    constraints["max_route_load"] = max(1, min(200, constraints["max_route_load"]))
+    constraints["avoid_late_penalty"] = max(0.5, min(10.0, constraints["avoid_late_penalty"]))
+    return constraints
+
+
+def extract_json_object(text: str) -> Optional[Dict[str, object]]:
+    match = re.search(r"\{.*\}", text or "", re.DOTALL)
+    if not match:
+        return None
+    try:
+        parsed = json.loads(match.group(0))
+    except json.JSONDecodeError:
+        return None
+    return parsed if isinstance(parsed, dict) else None
+
+
+@lru_cache(maxsize=1)
+def get_minicpm_llm():
+    if os.environ.get("DISABLE_MINICPM", "").lower() in {"1", "true", "yes"}:
+        return None
+    try:
+        from huggingface_hub import hf_hub_download
+        from llama_cpp import Llama
+    except Exception:
+        return None
+
+    try:
+        model_path = hf_hub_download(repo_id=MINICPM_REPO, filename=MINICPM_FILE)
+        return Llama(
+            model_path=model_path,
+            n_ctx=2048,
+            n_threads=max(1, min(4, os.cpu_count() or 2)),
+            n_gpu_layers=0,
+            verbose=False,
+        )
+    except Exception:
+        return None
+
+
+def minicpm_parse_dispatch_notes(notes: str) -> Tuple[Dict[str, object], str]:
+    fallback = normalize_constraints(parse_dispatch_notes(notes))
+    llm = get_minicpm_llm()
+    if llm is None:
+        fallback["source"] = "rule-fallback"
+        return fallback, "MiniCPM5 local runtime is unavailable, so the deterministic parser handled the notes."
+
+    prompt = f"""You are a dispatch constraint parser for a small delivery route planner.
+Return only valid JSON with these keys:
+prefer_early_priority: boolean
+avoid_late_penalty: number between 0.5 and 10
+max_route_load: integer
+depot_start: minutes after midnight as integer
+soft_due_before: optional minutes after midnight
+boost_terms: short lowercase strings
+
+Dispatcher notes:
+{notes}
+"""
+    try:
+        result = llm(
+            prompt,
+            max_tokens=180,
+            temperature=0.1,
+            top_p=0.9,
+            stop=["\n\n"],
+        )
+        text = result["choices"][0]["text"]
+        parsed = extract_json_object(text)
+        if parsed:
+            parsed["source"] = f"{MINICPM_REPO}/{MINICPM_FILE}"
+            return normalize_constraints(parsed), text.strip()
+    except Exception as exc:
+        fallback["source"] = "rule-fallback"
+        return fallback, f"MiniCPM5 parsing failed and fallback parser was used: {exc}"
+
+    fallback["source"] = "rule-fallback"
+    return fallback, "MiniCPM5 returned no valid JSON, so the deterministic parser handled the notes."
+
+
 def priority_weight(stop: Stop, constraints: Dict[str, object]) -> float:
     score = 0.0
     if stop.priority == "high":
@@ -172,62 +269,65 @@ def priority_weight(stop: Stop, constraints: Dict[str, object]) -> float:
     return score
 
 
-def nearest_neighbor(stops: List[Stop], constraints: Dict[str, object]) -> List[Stop]:
-    remaining = list(stops)
-    planned: List[Stop] = []
-    cur_lat, cur_lng = DEPOT["lat"], DEPOT["lng"]
-    current_time = int(constraints["depot_start"])
-    current_load = 0
-    route_capacity = int(constraints["max_route_load"])
-
-    while remaining:
-        best: Optional[Tuple[float, Stop]] = None
-        for stop in remaining:
-            distance = haversine_km(cur_lat, cur_lng, stop.lat, stop.lng)
-            eta = current_time + travel_minutes(distance)
-            late = max(0, eta - stop.due_time)
-            capacity_pressure = 999 if current_load + stop.demand > route_capacity else 0
-            wait = max(0, stop.ready_time - eta)
-            score = (
-                distance
-                + late * 0.12 * float(constraints["avoid_late_penalty"])
-                + wait * 0.01
-                + priority_weight(stop, constraints)
-                + capacity_pressure
-            )
-            if best is None or score < best[0]:
-                best = (score, stop)
-
-        chosen = best[1]
-        distance = haversine_km(cur_lat, cur_lng, chosen.lat, chosen.lng)
-        arrival = current_time + travel_minutes(distance)
-        current_time = max(arrival, chosen.ready_time) + chosen.service_min
-        current_load += chosen.demand
-        planned.append(chosen)
-        remaining.remove(chosen)
-        cur_lat, cur_lng = chosen.lat, chosen.lng
-
-    return planned
-
-
-def two_opt(route: List[Stop]) -> List[Stop]:
-    if len(route) < 4:
-        return route
-    improved = True
-    best = route[:]
-    while improved:
-        improved = False
-        for i in range(1, len(best) - 2):
-            for j in range(i + 1, len(best)):
-                if j - i == 1:
-                    continue
-                candidate = best[:]
-                candidate[i:j] = reversed(best[i:j])
-                if route_distance(candidate) + 1e-9 < route_distance(best):
-                    best = candidate
-                    improved = True
-        route = best
-    return best
+def score_route(route: List[Stop], start_minute: int) -> Tuple[int, float, int]:
+    plan, metrics = simulate_single_route(route, start_minute, route_id=1)
+    late_stops = sum(1 for item in plan if item.late_min > 0)
+    return int(metrics["late_min"]), float(metrics["distance_km"]), late_stops
+
+
+def best_order_for_group(stops: List[Stop], start_minute: int) -> List[Stop]:
+    if len(stops) <= 1:
+        return stops[:]
+    if len(stops) <= 7:
+        candidates = permutations(stops)
+    else:
+        ordered = sorted(stops, key=lambda s: (s.due_time, s.ready_time, -priority_weight(s, {})))
+        candidates = [ordered]
+
+    best_route: Optional[List[Stop]] = None
+    best_score: Optional[Tuple[int, float, int]] = None
+    for candidate in candidates:
+        route = list(candidate)
+        score = score_route(route, start_minute)
+        if best_score is None or score < best_score:
+            best_score = score
+            best_route = route
+    return best_route or stops[:]
+
+
+def build_capacity_routes(stops: List[Stop], constraints: Dict[str, object]) -> List[List[Stop]]:
+    capacity = int(constraints["max_route_load"])
+    ordered = sorted(
+        stops,
+        key=lambda stop: (
+            stop.due_time,
+            stop.ready_time,
+            0 if stop.priority == "high" else 1,
+            priority_weight(stop, constraints),
+        ),
+    )
+    routes: List[List[Stop]] = []
+    loads: List[int] = []
+    for stop in ordered:
+        best_idx = None
+        best_score = None
+        for idx, route in enumerate(routes):
+            if loads[idx] + stop.demand > capacity:
+                continue
+            trial = best_order_for_group(route + [stop], int(constraints["depot_start"]))
+            late, dist, late_stops = score_route(trial, int(constraints["depot_start"]))
+            score = (late, late_stops, dist)
+            if best_score is None or score < best_score:
+                best_score = score
+                best_idx = idx
+        if best_idx is None:
+            routes.append([stop])
+            loads.append(stop.demand)
+        else:
+            routes[best_idx] = best_order_for_group(routes[best_idx] + [stop], int(constraints["depot_start"]))
+            loads[best_idx] += stop.demand
+
+    return [best_order_for_group(route, int(constraints["depot_start"])) for route in routes]
 
 
 def route_distance(route: Iterable[Stop]) -> float:
@@ -241,7 +341,7 @@ def route_distance(route: Iterable[Stop]) -> float:
     return total
 
 
-def simulate(route: List[Stop], start_minute: int) -> Tuple[List[PlanStop], Dict[str, float]]:
+def simulate_single_route(route: List[Stop], start_minute: int, route_id: int) -> Tuple[List[PlanStop], Dict[str, float]]:
     cur_lat, cur_lng = DEPOT["lat"], DEPOT["lng"]
     current = start_minute
     plan: List[PlanStop] = []
@@ -260,6 +360,7 @@ def simulate(route: List[Stop], start_minute: int) -> Tuple[List[PlanStop], Dict
         plan.append(
             PlanStop(
                 stop=stop,
+                route_id=route_id,
                 arrival=arrival,
                 start=start,
                 depart=depart,
@@ -289,6 +390,33 @@ def simulate(route: List[Stop], start_minute: int) -> Tuple[List[PlanStop], Dict
     return plan, metrics
 
 
+def simulate_routes(routes: List[List[Stop]], start_minute: int) -> Tuple[List[PlanStop], Dict[str, float]]:
+    all_plan: List[PlanStop] = []
+    total_distance = 0.0
+    total_late = 0
+    total_wait = 0
+    total_load = 0
+    finish_min = start_minute
+    for route_id, route in enumerate(routes, start=1):
+        plan, metrics = simulate_single_route(route, start_minute, route_id)
+        all_plan.extend(plan)
+        total_distance += metrics["distance_km"]
+        total_late += metrics["late_min"]
+        total_wait += metrics["wait_min"]
+        total_load += metrics["load"]
+        finish_min = max(finish_min, metrics["finish_min"])
+    metrics = {
+        "distance_km": total_distance,
+        "late_min": total_late,
+        "wait_min": total_wait,
+        "finish_min": finish_min,
+        "load": total_load,
+        "routes": len(routes),
+        "on_time_rate": 100.0 * (1 - sum(1 for p in all_plan if p.late_min > 0) / max(1, len(all_plan))),
+    }
+    return all_plan, metrics
+
+
 def manual_route(stops: List[Stop]) -> List[Stop]:
     return sorted(stops, key=lambda stop: stop.manual_sequence)
 
@@ -297,7 +425,8 @@ def route_table(plan: List[PlanStop]) -> pd.DataFrame:
     return pd.DataFrame(
         [
             {
-                "#": idx + 1,
+                "Route": item.route_id,
+                "Stop #": sum(1 for prev in plan[:idx] if prev.route_id == item.route_id) + 1,
                 "Order": item.stop.order_id,
                 "Customer": item.stop.customer,
                 "Arrive": min_to_time(item.arrival),
@@ -321,19 +450,36 @@ def metrics_markdown(auto_metrics: Dict[str, float], manual_metrics: Dict[str, f
 
 | Metric | Manual baseline | Tiny Dispatch Coach | Change |
 |---|---:|---:|---:|
+| Routes / trips | {manual_metrics.get('routes', 1):.0f} | {auto_metrics.get('routes', 1):.0f} | |
 | Distance | {manual_metrics['distance_km']:.1f} km | {auto_metrics['distance_km']:.1f} km | {distance_delta:+.1f} km |
 | Late minutes | {manual_metrics['late_min']:.0f} | {auto_metrics['late_min']:.0f} | {late_delta:+.0f} |
 | Waiting minutes | {manual_metrics['wait_min']:.0f} | {auto_metrics['wait_min']:.0f} | {manual_metrics['wait_min'] - auto_metrics['wait_min']:+.0f} |
 | Finish time | {min_to_time(manual_metrics['finish_min'])} | {min_to_time(auto_metrics['finish_min'])} | |
 | On-time rate | {manual_metrics['on_time_rate']:.0f}% | {auto_metrics['on_time_rate']:.0f}% | {auto_metrics['on_time_rate'] - manual_metrics['on_time_rate']:+.0f} pts |
 
-**Coach note:** This route prioritizes high-risk time windows first, then uses a nearest-neighbor pass with a 2-opt cleanup. It is intentionally transparent so a dispatcher can override it.
+**Coach note:** The planner treats time-window risk as the first objective, then uses distance as a tie-breaker. It may split the day into multiple feasible trips when the notes imply a small van capacity.
 """
 
 
-def constraints_markdown(constraints: Dict[str, object]) -> str:
+def constraints_markdown(constraints: Dict[str, object], model_trace: str) -> str:
     rows = "\n".join(f"- **{key}**: `{value}`" for key, value in constraints.items())
-    return f"### Parsed Dispatcher Notes\n{rows}"
+    trace = escape(model_trace or "")
+    return f"""### OpenBMB MiniCPM5 Constraint Parse
+
+**Model path:** `{MINICPM_REPO}` / `{MINICPM_FILE}`  
+**Parameter count:** `{MINICPM_PARAMS}`  
+**Runtime target:** local GGUF via llama.cpp; deterministic parser fallback if the runtime is unavailable.
+
+{rows}
+
+<details>
+<summary>Parser trace</summary>
+
+```text
+{trace}
+```
+</details>
+"""
 
 
 def route_cards(plan: List[PlanStop]) -> str:
@@ -344,12 +490,12 @@ def route_cards(plan: List[PlanStop]) -> str:
             f"""
 <div class="route-card">
   <div class="route-card-top">
-    <span class="route-index">{idx}</span>
-    <span class="route-title">{item.stop.customer}</span>
+    <span class="route-index">{item.route_id}.{sum(1 for prev in plan[:idx - 1] if prev.route_id == item.route_id) + 1}</span>
+    <span class="route-title">{escape(item.stop.customer)}</span>
     <span class="route-status {status.replace(' ', '-')}">{status}</span>
   </div>
-  <div class="route-meta">{item.stop.order_id} · arrive {min_to_time(item.arrival)} · depart {min_to_time(item.depart)} · load {item.stop.demand}</div>
-  <div class="route-note">{item.stop.notes}</div>
+  <div class="route-meta">{escape(item.stop.order_id)} · route {item.route_id} · arrive {min_to_time(item.arrival)} · depart {min_to_time(item.depart)} · load {item.stop.demand}</div>
+  <div class="route-note">{escape(item.stop.notes)}</div>
 </div>
 """
         )
@@ -376,7 +522,15 @@ def route_map(plan: List[PlanStop]) -> str:
         return x, y
 
     coords = [xy(lat, lng) for lat, lng, _ in points]
-    path = " ".join(f"{x:.1f},{y:.1f}" for x, y in coords + [coords[0]])
+    route_paths = []
+    for route_id in sorted({item.route_id for item in plan}):
+        route_items = [item for item in plan if item.route_id == route_id]
+        route_points = [coords[0]]
+        for item in route_items:
+            idx = plan.index(item) + 1
+            route_points.append(coords[idx])
+        route_points.append(coords[0])
+        route_paths.append(" ".join(f"{x:.1f},{y:.1f}" for x, y in route_points))
     marker_html = []
     for idx, ((lat, lng, label), (x, y)) in enumerate(zip(points, coords)):
         is_depot = idx == 0
@@ -395,7 +549,7 @@ def route_map(plan: List[PlanStop]) -> str:
 <div class="map-wrap">
   <svg viewBox="0 0 900 560" role="img" aria-label="Route map">
     <rect x="0" y="0" width="900" height="560" rx="8" fill="#f8fafc" />
-    <path d="M {path}" fill="none" stroke="#2563eb" stroke-width="4" stroke-linejoin="round" stroke-linecap="round" opacity="0.78" />
+    {''.join(f'<path d="M {path}" fill="none" stroke="#2563eb" stroke-width="4" stroke-linejoin="round" stroke-linecap="round" opacity="0.62" />' for path in route_paths)}
     {''.join(marker_html)}
   </svg>
 </div>
@@ -404,15 +558,15 @@ def route_map(plan: List[PlanStop]) -> str:
 
 def analyze(file_obj, notes: str):
     stops = parse_orders(file_obj)
-    constraints = parse_dispatch_notes(notes)
-    auto_route = two_opt(nearest_neighbor(stops, constraints))
+    constraints, model_trace = minicpm_parse_dispatch_notes(notes)
+    auto_routes = build_capacity_routes(stops, constraints)
     manual = manual_route(stops)
-    auto_plan, auto_metrics = simulate(auto_route, int(constraints["depot_start"]))
-    manual_plan, manual_metrics = simulate(manual, int(constraints["depot_start"]))
+    auto_plan, auto_metrics = simulate_routes(auto_routes, int(constraints["depot_start"]))
+    manual_plan, manual_metrics = simulate_routes([manual], int(constraints["depot_start"]))
 
     return (
         metrics_markdown(auto_metrics, manual_metrics),
-        constraints_markdown(constraints),
+        constraints_markdown(constraints, model_trace),
         route_table(auto_plan),
         route_cards(auto_plan),
         route_map(auto_plan),
@@ -448,6 +602,29 @@ CUSTOM_CSS = """
   font-size: 16px;
   margin: 0;
 }
+.badges {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 18px;
+}
+.badge {
+  border: 1px solid rgba(255, 255, 255, .42);
+  border-radius: 999px;
+  padding: 5px 10px;
+  color: #f8fafc;
+  background: rgba(15, 118, 110, .58);
+  font-size: 13px;
+  font-weight: 700;
+}
+.model-note {
+  border: 1px solid #d6d3d1;
+  border-radius: 8px;
+  padding: 12px;
+  background: #f8fafc;
+  color: #292524;
+  font-size: 14px;
+}
 .route-cards {
   display: grid;
   grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
@@ -523,7 +700,14 @@ with gr.Blocks(
         """
 <section class="hero">
   <h1>Tiny Dispatch Coach</h1>
-  <p>Turn a small delivery sheet and messy dispatcher notes into a route plan, tradeoff explanation, and driver-ready cards. Built for small models, Gradio, and real neighborhood logistics.</p>
+  <p>Turn a small delivery sheet and messy dispatcher notes into route plans, tradeoff explanations, and driver-ready cards. Built around OpenBMB MiniCPM5-1B-GGUF plus a deterministic planner.</p>
+  <div class="badges">
+    <span class="badge">OpenBMB MiniCPM5</span>
+    <span class="badge">1.08B params</span>
+    <span class="badge">GGUF / llama.cpp</span>
+    <span class="badge">No cloud LLM API</span>
+    <span class="badge">Synthetic demo data</span>
+  </div>
 </section>
 """
     )
@@ -542,6 +726,16 @@ with gr.Blocks(
             )
             run = gr.Button("Plan route", variant="primary")
         with gr.Column(scale=1):
+            gr.HTML(
+                f"""
+<div class="model-note">
+  <strong>Small-model core:</strong><br>
+  <code>{MINICPM_REPO}</code><br>
+  <code>{MINICPM_FILE}</code><br>
+  The model parses human dispatch notes into JSON constraints. The route math is deterministic and auditable.
+</div>
+"""
+            )
             gr.Markdown(
                 """
 ### CSV columns
@@ -552,7 +746,9 @@ Leave the file empty to run the included sample route.
             )
 
     metrics = gr.Markdown()
-    constraints = gr.Markdown()
+    constraints = gr.Markdown(
+        "### OpenBMB MiniCPM5 Constraint Parse\nClick **Plan route** to parse notes with MiniCPM5-1B-GGUF and build the route plan."
+    )
     table = gr.Dataframe(label="Optimized route", interactive=False)
     cards = gr.HTML(label="Driver cards")
     map_html = gr.HTML(label="Route map")
@@ -562,11 +758,6 @@ Leave the file empty to run the included sample route.
         inputs=[order_file, notes],
         outputs=[metrics, constraints, table, cards, map_html],
     )
-    demo.load(
-        analyze,
-        inputs=[order_file, notes],
-        outputs=[metrics, constraints, table, cards, map_html],
-    )
 
 
 if __name__ == "__main__":

requirements.txt

@@ -1,3 +1,4 @@
 gradio>=6.14.0
 pandas>=2.2.0
-
+huggingface_hub>=0.34.0
+llama-cpp-python>=0.3.9