Add bundle CLIP runtime package

.gitattributes

@@ -1,35 +1,38 @@
+data/** filter=lfs diff=lfs merge=lfs -text
+models/** filter=lfs diff=lfs merge=lfs -text
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
 *.gz filter=lfs diff=lfs merge=lfs -text
 *.h5 filter=lfs diff=lfs merge=lfs -text
+*.index filter=lfs diff=lfs merge=lfs -text
 *.joblib filter=lfs diff=lfs merge=lfs -text
 *.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+config.json
+.env
+__pycache__/
+*.pyc
+logs/
+*.log
+build/
+dist/
+*.spec

README.md

@@ -1,3 +1,180 @@
 ---
 license: apache-2.0
+language:
+  - zh
+  - en
+tags:
+  - clip
+  - faiss
+  - ecommerce
+  - image-retrieval
+  - product-search
+  - temu
+pipeline_tag: image-feature-extraction
 ---
+
+<div align="center">
+
+# Bundle CLIP
+
+### Temu product retrieval pack for local bundle-building workflows
+
+<p>
+  <img alt="CLIP" src="https://img.shields.io/badge/CLIP-OpenCLIP-111827?style=for-the-badge">
+  <img alt="FAISS" src="https://img.shields.io/badge/FAISS-Listing%20Index-2563eb?style=for-the-badge">
+  <img alt="Local" src="https://img.shields.io/badge/Run-Local%209990-f97316?style=for-the-badge">
+  <img alt="License" src="https://img.shields.io/badge/License-Apache--2.0-10b981?style=for-the-badge">
+</p>
+
+**Image in. Product ideas out.**
+
+This repository packages a local CLIP + FAISS retrieval service for ecommerce bundle discovery.
+
+</div>
+
+---
+
+## What This Is
+
+`bundle-clip` is a self-contained local retrieval bundle used by the Auto Bundle workbench. It combines:
+
+| Layer | Role |
+| --- | --- |
+| Kimi planning | Turns an input product image into bundle-search directions. |
+| OpenCLIP encoder | Embeds image and text prompts into the same semantic space. |
+| FAISS listing index | Retrieves high-similarity Temu listings from the prepared metadata. |
+| Local web UI | Serves a review page at `http://127.0.0.1:9990/`. |
+
+The pack is designed for fast local review, private experimentation, and offline-ish product matching after the LFS assets are downloaded.
+
+## Repository Layout
+
+```text
+bundle-clip/
+├─ app/
+│  └─ listing_search.html
+├─ work/
+│  ├─ full_listing_server.py
+│  ├─ stdio_listing_worker.py
+│  ├─ full_clip_server.py
+│  └─ build_full_listing_index.py
+├─ models/
+│  └─ open_clip_pytorch_model.bin
+├─ data/
+│  ├─ yunqi_clip_training/
+│  │  └─ last_checkpoint.pt
+│  ├─ full_listing_index/
+│  │  ├─ products_listing.index
+│  │  ├─ products_listing_meta.runtime.json
+│  │  ├─ cleaning_report.json
+│  │  └─ progress.json
+│  └─ full_clip_index/
+│     └─ products_full_prices.json
+├─ config.example.json
+├─ .gitattributes
+└─ README.md
+```
+
+## Included Assets
+
+| Asset | Purpose |
+| --- | --- |
+| `models/open_clip_pytorch_model.bin` | Base OpenCLIP model weights. |
+| `data/yunqi_clip_training/last_checkpoint.pt` | Fine-tuned checkpoint for the bundle-search domain. |
+| `data/full_listing_index/products_listing.index` | FAISS index for listing retrieval. |
+| `data/full_listing_index/products_listing_meta.runtime.json` | Runtime metadata used to render product cards. |
+| `data/full_clip_index/products_full_prices.json` | Price metadata used by the local search UI. |
+
+Large files are tracked with Git LFS. Run `git lfs pull` after cloning.
+
+## Quick Start
+
+### 1. Clone With LFS
+
+```powershell
+git lfs install
+git clone https://huggingface.co/mikaassa/bundle-clip
+cd bundle-clip
+git lfs pull
+```
+
+### 2. Create Local Config
+
+```powershell
+Copy-Item config.example.json config.json
+```
+
+Fill in your private Kimi or Moonshot key:
+
+```json
+{
+  "kimi": {
+    "api_key": "YOUR_KIMI_API_KEY",
+    "endpoint": "https://api.moonshot.cn/v1/chat/completions",
+    "model": "kimi-k2.6",
+    "temperature": 0.6,
+    "max_completion_tokens": 1200
+  }
+}
+```
+
+`config.json` is ignored by Git. Keep real API keys local.
+
+### 3. Start The Local Service
+
+```powershell
+python .\work\full_listing_server.py
+```
+
+Open:
+
+```text
+http://127.0.0.1:9990/
+```
+
+## Workflow
+
+```mermaid
+flowchart LR
+  A[Product image] --> B[Kimi bundle directions]
+  B --> C[English listing prompt]
+  C --> D[OpenCLIP embedding]
+  D --> E[FAISS nearest-neighbor search]
+  E --> F[Temu product cards]
+```
+
+The local UI supports two review paths:
+
+| Mode | Use Case |
+| --- | --- |
+| Image bundle search | Upload a product image, let Kimi produce bundle directions, then retrieve matching listings. |
+| Direct CLIP search | Enter a manual listing keyword or prompt and search the index directly. |
+
+## Runtime Notes
+
+- Default local port: `9990`
+- Main service entry: `work/full_listing_server.py`
+- Workbench worker entry: `work/stdio_listing_worker.py`
+- Public page: `app/listing_search.html`
+- Main metadata image field: `MAINIMAGE`
+
+The service prefers repository-local `data/` and `models/` paths first. Older absolute-path fallbacks are only used when local assets are missing.
+
+## Safety
+
+- Do not commit `config.json`, `.env`, logs, or local cache output.
+- API keys should be supplied through `config.json` or environment variables only.
+- This repository is a local runtime pack, not a public hosted inference endpoint.
+- Product metadata and retrieval quality depend on the bundled index snapshot.
+
+## Environment Overrides
+
+```powershell
+$env:MOONSHOT_API_KEY="YOUR_KIMI_API_KEY"
+$env:KIMI_ENDPOINT="https://api.moonshot.cn/v1/chat/completions"
+$env:KIMI_MODEL="kimi-k2.6"
+```
+
+## License
+
+Released under the Apache 2.0 license. Check upstream model and data-source terms before redistribution or commercial deployment.

app/listing_search.html

@@ -0,0 +1,1288 @@
+<!doctype html>
+<html lang="zh-CN">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>纯 Listing 组货检索</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --ink: #231f1a;
+      --ink-soft: #3f3830;
+      --muted: #7b7167;
+      --line: #ded5c9;
+      --line-soft: #ece4da;
+      --panel: rgba(255, 252, 246, .88);
+      --panel-solid: #fffcf6;
+      --page: #f4efe7;
+      --paper: #fbf7ef;
+      --clay: #c56d3d;
+      --clay-dark: #9e4f2b;
+      --olive: #65724f;
+      --red: #b44f37;
+      --shadow: 0 22px 54px rgba(74, 51, 30, .10);
+      font-family: "Fraunces", "Iowan Old Style", "Noto Serif SC", "Microsoft YaHei UI", serif;
+    }
+
+    * { box-sizing: border-box; }
+    body {
+      min-height: 100vh;
+      margin: 0;
+      color: var(--ink);
+      background:
+        radial-gradient(circle at 9% 4%, rgba(219, 157, 102, .20), transparent 28%),
+        radial-gradient(circle at 92% 0%, rgba(101, 114, 79, .12), transparent 26%),
+        linear-gradient(135deg, #f8f1e7 0%, #f1eadf 48%, #eee4d7 100%);
+    }
+    body::before {
+      position: fixed;
+      inset: 0;
+      pointer-events: none;
+      content: "";
+      opacity: .42;
+      background-image:
+        linear-gradient(rgba(120, 92, 63, .045) 1px, transparent 1px),
+        linear-gradient(90deg, rgba(120, 92, 63, .035) 1px, transparent 1px);
+      background-size: 42px 42px;
+      mask-image: linear-gradient(to bottom, #000, transparent 82%);
+    }
+    button, input, textarea {
+      font: inherit;
+    }
+    .shell {
+      width: min(1500px, calc(100% - 40px));
+      margin: 0 auto;
+      padding: 30px 0 44px;
+    }
+    .topbar {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      gap: 22px;
+      align-items: end;
+      margin-bottom: 18px;
+      padding: 18px 20px;
+      border: 1px solid rgba(94, 73, 55, .12);
+      border-radius: 28px;
+      background: rgba(255, 251, 244, .68);
+      box-shadow: 0 1px 0 rgba(255,255,255,.7) inset;
+      backdrop-filter: blur(18px);
+    }
+    .eyebrow {
+      margin: 0 0 8px;
+      color: var(--clay-dark);
+      font: 700 11px/1.2 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+      letter-spacing: .16em;
+      text-transform: uppercase;
+    }
+    h1 {
+      margin: 0;
+      font-size: clamp(30px, 4vw, 48px);
+      font-weight: 760;
+      letter-spacing: -.045em;
+      line-height: 1.05;
+    }
+    .subtitle {
+      margin: 10px 0 0;
+      max-width: 860px;
+      color: var(--muted);
+      font: 14px/1.8 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .layout {
+      display: flex;
+      min-height: calc(100vh - 170px);
+      flex-direction: column;
+      gap: 18px;
+    }
+    .panel {
+      border: 1px solid rgba(96, 73, 51, .14);
+      border-radius: 28px;
+      background: var(--panel);
+      box-shadow: var(--shadow), 0 1px 0 rgba(255,255,255,.72) inset;
+      backdrop-filter: blur(20px);
+    }
+    .controls {
+      padding: 18px;
+    }
+    .section-title {
+      margin: 0 0 14px;
+      font-size: 19px;
+      letter-spacing: -.02em;
+    }
+    .field-label {
+      display: block;
+      margin: 17px 0 8px;
+      color: var(--ink-soft);
+      font: 800 12px/1.4 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+      letter-spacing: .02em;
+    }
+    .dropzone {
+      display: grid;
+      min-height: 226px;
+      place-items: center;
+      padding: 16px;
+      border: 1.5px dashed rgba(126, 103, 80, .34);
+      border-radius: 22px;
+      background:
+        linear-gradient(180deg, rgba(255,255,255,.56), rgba(255,248,237,.72)),
+        repeating-linear-gradient(-45deg, rgba(159, 111, 70, .035) 0 1px, transparent 1px 9px);
+      text-align: center;
+      cursor: pointer;
+      transition: transform .18s cubic-bezier(.2,.8,.2,1), border-color .18s cubic-bezier(.2,.8,.2,1), background .18s cubic-bezier(.2,.8,.2,1);
+    }
+    .dropzone:hover,
+    .dropzone.active {
+      transform: translateY(-1px);
+      border-color: rgba(197, 109, 61, .74);
+      background: #fff9f0;
+    }
+    .dropzone input { display: none; }
+    .preview {
+      display: none;
+      width: 100%;
+      max-height: 270px;
+      border-radius: 18px;
+      object-fit: contain;
+      background: #eee5d8;
+      box-shadow: 0 16px 32px rgba(61, 43, 25, .12);
+    }
+    .preview.visible { display: block; }
+    .drop-copy.hidden { display: none; }
+    .drop-copy strong {
+      display: block;
+      margin-bottom: 8px;
+      font-size: 16px;
+    }
+    .drop-copy span {
+      color: var(--muted);
+      font: 12px/1.7 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    textarea {
+      width: 100%;
+      min-height: 112px;
+      resize: vertical;
+      padding: 13px 14px;
+      border: 1px solid var(--line);
+      border-radius: 16px;
+      outline: 0;
+      color: var(--ink);
+      line-height: 1.62;
+      background: rgba(255, 253, 249, .86);
+      box-shadow: 0 1px 0 rgba(255,255,255,.75) inset;
+      font-family: "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    textarea:focus,
+    input:focus {
+      border-color: rgba(197, 109, 61, .72);
+      box-shadow: 0 0 0 4px rgba(197, 109, 61, .13), 0 1px 0 rgba(255,255,255,.75) inset;
+    }
+    .options {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 10px;
+    }
+    .option small {
+      display: block;
+      margin-bottom: 6px;
+      color: var(--muted);
+      font: 12px/1.4 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .option input {
+      width: 100%;
+      padding: 11px 12px;
+      border: 1px solid var(--line);
+      border-radius: 15px;
+      outline: 0;
+      color: var(--ink);
+      background: rgba(255, 253, 249, .92);
+      font-family: "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .button-row {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 10px;
+      margin-top: 12px;
+    }
+    button {
+      min-height: 44px;
+      border-radius: 999px;
+      font: 850 14px/1 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+      cursor: pointer;
+      transition: transform .16s cubic-bezier(.2,.8,.2,1), box-shadow .16s cubic-bezier(.2,.8,.2,1), background .16s cubic-bezier(.2,.8,.2,1);
+    }
+    button:hover:not(:disabled) {
+      transform: translateY(-1px);
+    }
+    .primary {
+      border: 1px solid rgba(116, 55, 25, .14);
+      color: #fffaf3;
+      background: linear-gradient(180deg, var(--clay), var(--clay-dark));
+      box-shadow: 0 12px 22px rgba(158, 79, 43, .22), 0 1px 0 rgba(255,255,255,.28) inset;
+    }
+    .secondary {
+      border: 1px solid rgba(103, 82, 62, .18);
+      color: var(--ink);
+      background: rgba(255, 252, 246, .76);
+      box-shadow: 0 1px 0 rgba(255,255,255,.72) inset;
+    }
+    button:disabled {
+      cursor: wait;
+      opacity: .62;
+      transform: none;
+    }
+    .hint {
+      margin: 12px 0 0;
+      color: var(--muted);
+      font: 12px/1.75 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .build-panel {
+      margin-top: 16px;
+      padding: 14px;
+      border: 1px solid rgba(104, 84, 65, .13);
+      border-radius: 20px;
+      background: rgba(246, 238, 228, .62);
+    }
+    .progress-line {
+      display: flex;
+      justify-content: space-between;
+      gap: 12px;
+      color: var(--muted);
+      font: 12px/1.45 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .bar {
+      height: 8px;
+      margin: 10px 0;
+      overflow: hidden;
+      border-radius: 999px;
+      background: #e8dccf;
+    }
+    .bar span {
+      display: block;
+      width: 0;
+      height: 100%;
+      background: linear-gradient(90deg, var(--olive), #9c8d63);
+      transition: width .25s cubic-bezier(.2,.8,.2,1);
+    }
+    .log {
+      height: 140px;
+      margin: 10px 0 0;
+      padding: 12px;
+      overflow: auto;
+      border-radius: 16px;
+      color: #f4eadb;
+      background: #2a2119;
+      font: 12px/1.55 "Cascadia Mono", Consolas, monospace;
+      white-space: pre-wrap;
+    }
+    .kimi-prompt {
+      min-height: 230px;
+      font-size: 12px;
+      line-height: 1.62;
+      background:
+        linear-gradient(90deg, rgba(197,109,61,.10) 0 1px, transparent 1px),
+        rgba(255, 253, 249, .92);
+      background-size: 24px 100%;
+      padding-left: 18px;
+    }
+    .results-panel {
+      min-height: min(70vh, 760px);
+      padding: 20px;
+    }
+    .results-head {
+      display: flex;
+      justify-content: space-between;
+      gap: 14px;
+      align-items: center;
+      margin-bottom: 14px;
+    }
+    .results-head h2 {
+      margin: 0;
+      font-size: 22px;
+      letter-spacing: -.025em;
+    }
+    .status {
+      color: var(--muted);
+      font: 13px/1.45 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    #serverStatus {
+      padding: 9px 12px;
+      border: 1px solid rgba(104, 84, 65, .15);
+      border-radius: 999px;
+      background: rgba(255,252,246,.74);
+      white-space: nowrap;
+    }
+    .results-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fill, minmax(212px, 1fr));
+      gap: 14px;
+    }
+    .plan-panel {
+      display: none;
+      margin-bottom: 16px;
+      padding: 15px;
+      border: 1px solid rgba(197, 109, 61, .22);
+      border-radius: 22px;
+      background: linear-gradient(180deg, rgba(255, 249, 239, .92), rgba(250, 241, 230, .72));
+      box-shadow: 0 1px 0 rgba(255,255,255,.8) inset;
+    }
+    .plan-panel.visible { display: none; }
+    .plan-panel h3 {
+      margin: 0 0 8px;
+      font-size: 16px;
+      letter-spacing: -.01em;
+    }
+    .plan-summary {
+      margin: 0 0 12px;
+      color: var(--muted);
+      font: 13px/1.55 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .prompt-editor {
+      display: grid;
+      gap: 9px;
+      max-height: 360px;
+      overflow: auto;
+      padding-right: 4px;
+    }
+    .prompt-edit-row {
+      display: grid;
+      grid-template-columns: 34px 1fr 1.25fr;
+      gap: 8px;
+      align-items: center;
+    }
+    .prompt-edit-index {
+      color: var(--clay-dark);
+      font: 900 12px/1 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .prompt-edit-row input {
+      width: 100%;
+      min-height: 36px;
+      padding: 8px 10px;
+      border: 1px solid var(--line);
+      border-radius: 13px;
+      outline: 0;
+      color: var(--ink);
+      background: rgba(255,255,255,.72);
+      font: 12px/1.4 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .plan-tools {
+      display: flex;
+      gap: 10px;
+      align-items: center;
+      margin-top: 13px;
+    }
+    .plan-tools button {
+      min-height: 38px;
+      padding: 0 16px;
+      font-size: 13px;
+    }
+    .prompt-group {
+      margin-bottom: 18px;
+      padding: 14px;
+      border: 1px solid rgba(104, 84, 65, .14);
+      border-radius: 22px;
+      background: rgba(255, 252, 246, .72);
+      box-shadow: 0 1px 0 rgba(255,255,255,.72) inset;
+    }
+    .prompt-group-title {
+      margin: 0 0 5px;
+      font-size: 16px;
+      letter-spacing: -.015em;
+    }
+    .prompt-group-prompt {
+      margin: 0 0 13px;
+      color: var(--muted);
+      font: 12px/1.6 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .empty {
+      display: grid;
+      min-height: 462px;
+      place-items: center;
+      border: 1px dashed rgba(104, 84, 65, .22);
+      border-radius: 22px;
+      color: var(--muted);
+      background: rgba(255, 252, 246, .44);
+      text-align: center;
+      font-family: "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .empty strong {
+      display: block;
+      margin-bottom: 8px;
+      color: var(--ink);
+      font-family: "Fraunces", "Iowan Old Style", "Noto Serif SC", serif;
+      font-size: 18px;
+    }
+    .product {
+      overflow: hidden;
+      border: 1px solid rgba(104, 84, 65, .14);
+      border-radius: 20px;
+      background: rgba(255, 252, 246, .86);
+      box-shadow: 0 12px 28px rgba(74, 51, 30, .08);
+      transition: transform .18s cubic-bezier(.2,.8,.2,1), box-shadow .18s cubic-bezier(.2,.8,.2,1);
+    }
+    .product-media {
+      position: relative;
+      overflow: hidden;
+      background: #eadfce;
+    }
+    .product-tag {
+      position: absolute;
+      left: 10px;
+      right: 10px;
+      bottom: 10px;
+      display: none;
+      padding: 7px 9px;
+      border: 1px solid rgba(255,255,255,.48);
+      border-radius: 999px;
+      color: #fffaf3;
+      background: rgba(36, 29, 23, .68);
+      box-shadow: 0 12px 26px rgba(22, 18, 14, .22);
+      font: 11px/1.25 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      backdrop-filter: blur(10px);
+    }
+    .product-tag.visible {
+      display: block;
+    }
+    .product:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 18px 34px rgba(74, 51, 30, .12);
+    }
+    .product-image {
+      display: block;
+      width: 100%;
+      height: 190px;
+      object-fit: cover;
+      background: #eadfce;
+    }
+    .product-body {
+      padding: 12px;
+    }
+    .product-meta {
+      display: flex;
+      justify-content: space-between;
+      gap: 8px;
+      margin-bottom: 8px;
+      color: var(--muted);
+      font: 12px/1.45 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    .score {
+      color: var(--olive);
+      font-weight: 900;
+    }
+    .product-title {
+      min-height: 64px;
+      margin: 0 0 10px;
+      font: 13px/1.52 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+      display: -webkit-box;
+      -webkit-line-clamp: 3;
+      -webkit-box-orient: vertical;
+      overflow: hidden;
+    }
+    .product-footer {
+      display: flex;
+      justify-content: space-between;
+      gap: 8px;
+      padding-top: 10px;
+      border-top: 1px solid var(--line-soft);
+    }
+    .price {
+      color: var(--red);
+      font-size: 17px;
+      font-weight: 900;
+    }
+    .sales {
+      color: var(--muted);
+      font: 12px/1.45 "Microsoft YaHei UI", "Noto Sans SC", sans-serif;
+    }
+    [hidden] {
+      display: none !important;
+    }
+    .composer-head {
+      display: flex;
+      justify-content: space-between;
+      gap: 14px;
+      align-items: center;
+      margin-bottom: 14px;
+    }
+    .mode-tabs {
+      display: flex;
+      gap: 6px;
+      padding: 4px;
+      border: 1px solid rgba(104, 84, 65, .14);
+      border-radius: 999px;
+      background: rgba(246, 238, 228, .62);
+    }
+    .mode-tab {
+      min-height: 34px;
+      padding: 0 13px;
+      border: 0;
+      color: var(--muted);
+      background: transparent;
+      box-shadow: none;
+      font-size: 13px;
+    }
+    .mode-tab.active {
+      color: var(--ink);
+      background: rgba(255, 252, 246, .92);
+      box-shadow: 0 1px 0 rgba(255,255,255,.72) inset, 0 8px 18px rgba(74, 51, 30, .08);
+    }
+    .composer-mode {
+      display: none;
+    }
+    .composer-mode.active {
+      display: grid;
+      grid-template-columns: minmax(260px, 360px) minmax(300px, 1fr);
+      gap: 14px;
+      align-items: stretch;
+    }
+    .composer-mode.text-mode.active {
+      grid-template-columns: 1fr;
+    }
+    .composer-bottom {
+      display: grid;
+      grid-template-columns: minmax(260px, 360px) minmax(280px, 1fr) auto;
+      gap: 12px;
+      align-items: end;
+      margin-top: 14px;
+    }
+    .composer-actions {
+      display: flex;
+      gap: 10px;
+      justify-content: flex-end;
+      align-items: center;
+    }
+    .composer-actions button {
+      min-width: 138px;
+      padding: 0 18px;
+    }
+    .composer-log {
+      margin-top: 14px;
+    }
+    @media (max-width: 900px) {
+      .topbar {
+        align-items: stretch;
+        grid-template-columns: 1fr;
+      }
+      .composer-mode.active,
+      .composer-bottom {
+        grid-template-columns: 1fr;
+      }
+      .composer-actions {
+        justify-content: stretch;
+      }
+      .composer-actions button {
+        flex: 1;
+      }
+    }
+
+    /* Industrial terminal skin: keeps the agreed interaction model, only changes the surface language. */
+    :root {
+      --ink: #f2f2ec;
+      --ink-soft: #d7d3c8;
+      --muted: #8f897f;
+      --line: #302b25;
+      --line-soft: #26221e;
+      --panel: #151411;
+      --panel-solid: #151411;
+      --page: #0d0d0b;
+      --paper: #151411;
+      --clay: #ff6a32;
+      --clay-dark: #d94f1f;
+      --olive: #42dfff;
+      --red: #ff614a;
+      --shadow: none;
+      font-family: "JetBrains Mono", "Cascadia Mono", Consolas, "Microsoft YaHei UI", monospace;
+    }
+    body {
+      color: var(--ink);
+      background: #0d0d0b;
+    }
+    body::before {
+      opacity: .22;
+      background:
+        repeating-linear-gradient(0deg, transparent 0 2px, rgba(255,255,255,.035) 2px 3px),
+        linear-gradient(90deg, rgba(255,106,50,.04) 1px, transparent 1px);
+      background-size: 100% 4px, 82px 100%;
+      mask-image: none;
+    }
+    .shell {
+      width: min(1240px, calc(100% - 44px));
+      padding-top: 32px;
+    }
+    .topbar,
+    .panel,
+    .controls,
+    .results-panel,
+    .build-panel,
+    .prompt-group,
+    .product,
+    .empty,
+    textarea,
+    input,
+    button,
+    .dropzone,
+    .mode-tabs,
+    .mode-tab,
+    #serverStatus {
+      border-radius: 0;
+      box-shadow: none;
+      backdrop-filter: none;
+    }
+    .topbar {
+      padding: 0 0 28px;
+      border: 0;
+      border-bottom: 1px solid #302b25;
+      background: transparent;
+    }
+    .eyebrow {
+      color: var(--clay);
+      font: 900 10px/1.2 "JetBrains Mono", "Cascadia Mono", Consolas, monospace;
+      letter-spacing: .22em;
+    }
+    .eyebrow::before {
+      content: "POD / ";
+    }
+    h1 {
+      max-width: 760px;
+      color: #fffdf5;
+      font-family: "Arial Black", "Microsoft YaHei UI", sans-serif;
+      font-size: clamp(34px, 4.6vw, 56px);
+      font-weight: 950;
+      letter-spacing: -.06em;
+      line-height: .92;
+      text-shadow: 2px 2px 0 #0d0d0b, 4px 4px 0 rgba(66,223,255,.45);
+      text-transform: uppercase;
+    }
+    .subtitle,
+    .hint,
+    .status,
+    .field-label,
+    .option small,
+    .drop-copy span,
+    .plan-summary,
+    .prompt-group-prompt,
+    .sales,
+    .product-meta {
+      color: var(--muted);
+      font-family: "JetBrains Mono", "Cascadia Mono", Consolas, "Microsoft YaHei UI", monospace;
+    }
+    #serverStatus {
+      padding: 10px 12px;
+      border: 1px solid #302b25;
+      color: var(--olive);
+      background: #171511;
+      text-transform: uppercase;
+    }
+    .layout {
+      gap: 16px;
+    }
+    .panel {
+      border: 1px solid #302b25;
+      background: #151411;
+    }
+    .results-panel {
+      min-height: 68vh;
+      padding: 18px;
+    }
+    .results-head {
+      padding-bottom: 14px;
+      border-bottom: 1px solid #302b25;
+    }
+    .results-head h2,
+    .section-title,
+    .plan-panel h3,
+    .prompt-group-title {
+      color: #fffdf5;
+      font-family: "Arial Black", "Microsoft YaHei UI", sans-serif;
+      letter-spacing: -.04em;
+    }
+    .results-grid {
+      grid-template-columns: repeat(auto-fill, minmax(190px, 1fr));
+      gap: 1px;
+      padding: 1px;
+      background: #302b25;
+    }
+    .empty {
+      border: 1px dashed #3b352e;
+      color: var(--muted);
+      background: #11100e;
+    }
+    .empty strong {
+      color: #fffdf5;
+      font-family: "Arial Black", "Microsoft YaHei UI", sans-serif;
+      letter-spacing: -.03em;
+    }
+    .controls {
+      padding: 16px;
+    }
+    .composer-head {
+      padding-bottom: 14px;
+      border-bottom: 1px solid #302b25;
+    }
+    .mode-tabs {
+      gap: 1px;
+      padding: 0;
+      border: 1px solid #302b25;
+      background: #302b25;
+    }
+    .mode-tab {
+      min-height: 36px;
+      color: var(--muted);
+      background: #151411;
+      text-transform: uppercase;
+    }
+    .mode-tab.active {
+      color: #0d0d0b;
+      background: var(--olive);
+    }
+    .dropzone {
+      min-height: 176px;
+      border: 1px dashed #3b352e;
+      background: #11100e;
+    }
+    .dropzone:hover,
+    .dropzone.active {
+      transform: none;
+      border-color: var(--clay);
+      background: #171511;
+    }
+    .drop-copy strong {
+      color: #fffdf5;
+      font-family: "Arial Black", "Microsoft YaHei UI", sans-serif;
+      letter-spacing: -.035em;
+    }
+    .preview,
+    .product-image {
+      background: #0f0e0c;
+    }
+    textarea,
+    .option input,
+    .prompt-edit-row input {
+      border: 1px solid #302b25;
+      color: #fffdf5;
+      background: #0f0e0c;
+      box-shadow: none;
+    }
+    textarea:focus,
+    input:focus {
+      border-color: var(--clay);
+      box-shadow: 0 0 0 1px var(--clay);
+    }
+    .kimi-prompt {
+      min-height: 176px;
+      background:
+        repeating-linear-gradient(90deg, transparent 0 23px, rgba(255,106,50,.12) 23px 24px),
+        #0f0e0c;
+    }
+    .composer-bottom {
+      border-top: 1px solid #302b25;
+      padding-top: 14px;
+    }
+    .primary {
+      border: 1px solid var(--clay);
+      color: #0d0d0b;
+      background: var(--clay);
+      text-transform: uppercase;
+    }
+    .secondary {
+      border: 1px solid #3b352e;
+      color: #fffdf5;
+      background: #1b1915;
+      text-transform: uppercase;
+    }
+    button:hover:not(:disabled) {
+      transform: none;
+      outline: 1px solid var(--olive);
+      outline-offset: -2px;
+    }
+    .build-panel {
+      border: 1px solid #302b25;
+      background: #11100e;
+    }
+    .bar {
+      border: 1px solid #302b25;
+      background: #0d0d0b;
+    }
+    .bar span {
+      background: var(--olive);
+    }
+    .log {
+      border: 1px solid #302b25;
+      color: #e9e3d4;
+      background: #080807;
+    }
+    .product {
+      border: 0;
+      background: #151411;
+    }
+    .product:hover {
+      transform: none;
+      outline: 1px solid var(--clay);
+      outline-offset: -1px;
+      box-shadow: none;
+    }
+    .product-media {
+      background: #0f0e0c;
+    }
+    .product-tag {
+      left: 8px;
+      right: 8px;
+      bottom: 8px;
+      border: 1px solid rgba(66, 223, 255, .58);
+      color: var(--olive);
+      background: rgba(8, 8, 7, .82);
+      box-shadow: none;
+      text-transform: uppercase;
+      backdrop-filter: none;
+    }
+    .product-title {
+      min-height: 48px;
+      color: #fffdf5;
+      font-family: "JetBrains Mono", "Cascadia Mono", Consolas, "Microsoft YaHei UI", monospace;
+      font-size: 12px;
+      line-height: 1.35;
+      -webkit-line-clamp: 2;
+    }
+    .product-footer {
+      border-top: 1px solid #302b25;
+    }
+    .price {
+      color: var(--clay);
+      font-family: "Arial Black", "Microsoft YaHei UI", sans-serif;
+      font-size: 18px;
+    }
+  </style>
+</head>
+<body>
+  <main class="shell">
+    <header class="topbar">
+      <div>
+        <p class="eyebrow">IMAGE TO KIMI TO LISTING CLIP</p>
+        <h1>纯 Listing 组货检索</h1>
+        <p class="subtitle">图片交给 Kimi 生成 10 个可组货商品检索词，再用纯 listing CLIP 索引召回；下方文本框单独用于直接检索 CLIP。</p>
+      </div>
+      <div class="status" id="serverStatus">9990 等待连接</div>
+    </header>
+
+    <section class="layout">
+      <section class="panel results-panel">
+        <div class="results-head">
+          <h2>匹配结果</h2>
+          <span class="status" id="status">等待输入</span>
+        </div>
+        <div class="plan-panel" id="planPanel">
+          <h3>Kimi 组货商品 JSON</h3>
+          <p class="plan-summary" id="planSummary"></p>
+          <div class="prompt-editor" id="promptEditor"></div>
+          <div class="plan-tools">
+            <button class="primary" id="editedPromptButton" type="button">用编辑后 Prompt 检索</button>
+            <span class="status">改英文 en 最影响 CLIP 召回</span>
+          </div>
+        </div>
+        <div id="resultsGrid">
+          <div class="empty"><div><strong>还没有结果</strong><span>上传图片跑 Kimi，或输入文本直接检索 CLIP</span></div></div>
+        </div>
+      </section>
+
+      <aside class="panel controls">
+        <div class="composer-head">
+          <h2 class="section-title">输入</h2>
+          <div class="mode-tabs" aria-label="输入模式">
+            <button class="mode-tab active" id="imageModeTab" type="button">图片组货</button>
+            <button class="mode-tab" id="textModeTab" type="button">直接 CLIP</button>
+          </div>
+        </div>
+
+        <section class="composer-mode active" id="imageMode">
+          <label class="dropzone" id="dropzone" for="imageInput">
+            <input id="imageInput" type="file" accept="image/*">
+            <img class="preview" id="preview" alt="待分析图片预览">
+            <span class="drop-copy" id="dropCopy">
+              <strong>点击或拖入商品图片</strong>
+              <span>Image -> Kimi -> 组货商品 JSON -> Listing CLIP</span>
+            </span>
+          </label>
+          <div>
+            <label class="field-label" for="kimiPromptInput">发给 Kimi 的 Prompt（可编辑）</label>
+            <textarea class="kimi-prompt" id="kimiPromptInput"></textarea>
+          </div>
+        </section>
+
+        <section class="composer-mode text-mode" id="textMode">
+          <div>
+            <label class="field-label" for="queryInput">CLIP 检索词 / Listing 搜索</label>
+            <textarea id="queryInput" placeholder="这里不发给 Kimi，只用于直接检索 CLIP。例如：transparent storage box for makeup organizer"></textarea>
+          </div>
+        </section>
+
+        <div class="composer-bottom">
+          <div class="options">
+            <label class="option">
+              <small>最低价格 USD</small>
+              <input id="minPrice" type="number" min="0" step="0.01" placeholder="不限">
+            </label>
+            <label class="option">
+              <small>最高价格 USD</small>
+              <input id="maxPrice" type="number" min="0" step="0.01" placeholder="不限">
+            </label>
+          </div>
+          <p class="hint">Kimi 请求只带图片；直接 CLIP 模式只使用文本。结果卡片只显示图片、方向、标题、价格和销量。</p>
+          <div class="composer-actions">
+            <button class="primary" id="assemblyButton" type="button">生成 Kimi 组货方案</button>
+            <button class="secondary" id="searchButton" type="button">仅 Listing 检索</button>
+          </div>
+        </div>
+      </aside>
+    </section>
+  </main>
+
+  <script>
+    const apiBase = 'http://127.0.0.1:9990';
+    const defaultKimiPrompt = `你是跨境电商组货商品检索词生成器。你只根据用户上传的图片生成可一起售卖/一起购买的商品检索词。
+
+任务：输出10个“具体可采购商品”，用于后续纯 listing CLIP 检索。
+
+生成原则：
+1. 不要只找外观相似品；优先覆盖互补品、同场景加购、替代升级、耗材补充、收纳展示、维护清洁、配套工具、礼盒套装里的其他商品。
+2. 每条必须是具体商品，不要写大类、策略、理由或营销词。不要输出“配件、用品、产品、套装、工具”这种过宽泛词，除非前面有清晰具体限定。
+3. 中文 zh 要像能直接给采购看的商品短名：主体品类 + 关键材质/结构/场景/人群/规格，尽量 6-18 个中文字符。
+4. 英文 en 要像英文 listing 标题检索词：6-14 个英文词，必须包含明确 product noun，并尽量包含 material / shape / color / scene / target user / size / function 中的2-4个要素。
+5. 如果图片主体不确定，根据最明显视觉元素推断；不要解释不确定性。
+6. 10条之间要有明显差异，避免同义改写刷数量。
+
+输出格式：只返回合法 JSON 对象，且只能包含 prompts 字段。
+prompts 是长度为10的数组，每个元素只能包含 zh 和 en 两个字段。`;
+    let selectedFile = null;
+    let currentPlan = { prompts: [] };
+
+    // Escape API-provided text before inserting it into cards.
+    function escapeHtml(value) {
+      const text = String(value === null || value === undefined ? '' : value);
+      return text.replace(/[&<>"']/g, function replaceCharacter(character) {
+        const entities = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' };
+        return entities[character];
+      });
+    }
+
+    // Build the product image URL returned by the listing service.
+    function getProductImageUrl(product) {
+      if (product.img_url && /^https?:\/\//i.test(String(product.img_url))) return `${apiBase}/api/cdn/image?url=${encodeURIComponent(String(product.img_url))}`;
+      return '';
+    }
+
+    // Remove the whole product card when its CDN image fails to load.
+    function handleProductImageError(imageElement) {
+      const productCard = imageElement.closest('.product');
+      if (productCard) productCard.remove();
+    }
+
+    // Show the selected image locally before sending it to Kimi.
+    function showPreview(file) {
+      const preview = document.getElementById('preview');
+      const dropCopy = document.getElementById('dropCopy');
+      if (!file) {
+        preview.removeAttribute('src');
+        preview.classList.remove('visible');
+        dropCopy.classList.remove('hidden');
+        return;
+      }
+      preview.src = URL.createObjectURL(file);
+      preview.classList.add('visible');
+      dropCopy.classList.add('hidden');
+    }
+
+    // Accept an image from the file picker or drag-and-drop area.
+    function setSelectedFile(file) {
+      if (!file || !file.type || !file.type.startsWith('image/')) return;
+      selectedFile = file;
+      showPreview(file);
+      document.getElementById('status').textContent = `已选择：${file.name}`;
+    }
+
+    // Render one search result card.
+    function renderProductCard(product, index) {
+      const title = product.title || product.listing_text || product.title_en || `商品 ${product.id || index + 1}`;
+      const price = product.price_usd === undefined || product.price_usd === null || product.price_usd === '' ? '--' : `$${Number(product.price_usd).toFixed(2)}`;
+      const salesValue = product.sales_total === undefined || product.sales_total === null ? product.sales : product.sales_total;
+      const sales = salesValue === undefined || salesValue === '' || salesValue === null ? '' : `销量 ${salesValue}`;
+      const imageUrl = getProductImageUrl(product);
+      const tag = product.bundle_tag || product.search_prompt || product.search_prompt_en || '';
+      return `<article class="product">
+        <div class="product-media">
+          <img class="product-image" src="${escapeHtml(imageUrl)}" alt="${escapeHtml(title)}" onerror="handleProductImageError(this)">
+          <span class="product-tag${tag ? ' visible' : ''}">${escapeHtml(tag)}</span>
+        </div>
+        <div class="product-body">
+          <p class="product-title">${escapeHtml(title)}</p>
+          <div class="product-footer"><span class="price">${escapeHtml(price)}</span><span class="sales">${escapeHtml(sales)}</span></div>
+        </div>
+      </article>`;
+    }
+
+    // Render all cards or an empty state.
+    function renderResults(results) {
+      const grid = document.getElementById('resultsGrid');
+      if (!results || results.length === 0) {
+        grid.innerHTML = '<div class="empty"><div><strong>没有符合条件的商品</strong><span>换个英文 prompt 或放宽价格范围</span></div></div>';
+        return;
+      }
+      let html = '<div class="results-grid">';
+      let index = 0;
+      while (index < results.length) {
+        html += renderProductCard(results[index], index);
+        index += 1;
+      }
+      grid.innerHTML = `${html}</div>`;
+    }
+
+    // Render Kimi's bundle-product plan as editable prompt rows.
+    function renderPlan(plan, resultCount) {
+      const panel = document.getElementById('planPanel');
+      const prompts = plan && Array.isArray(plan.prompts) ? plan.prompts : [];
+      currentPlan = { prompts };
+      document.getElementById('planSummary').textContent = `${prompts.length} 个组货商品 · 每个 Top 1 · ${resultCount} 个召回位 · thinking disabled`;
+      let editorHtml = '';
+      let promptIndex = 0;
+      while (promptIndex < prompts.length) {
+        const prompt = prompts[promptIndex] || {};
+        editorHtml += `<div class="prompt-edit-row">
+          <span class="prompt-edit-index">#${promptIndex + 1}</span>
+          <input class="prompt-zh" data-index="${promptIndex}" value="${escapeHtml(prompt.zh || '')}" placeholder="中文商品名">
+          <input class="prompt-en" data-index="${promptIndex}" value="${escapeHtml(prompt.en || '')}" placeholder="English listing keywords">
+        </div>`;
+        promptIndex += 1;
+      }
+      document.getElementById('promptEditor').innerHTML = editorHtml;
+      panel.classList.add('visible');
+    }
+
+    // Read the currently edited prompt rows back into JSON shape.
+    function readEditedPlan() {
+      const rows = Array.from(document.querySelectorAll('.prompt-edit-row'));
+      const prompts = rows.map(function mapPromptRow(row) {
+        return {
+          zh: row.querySelector('.prompt-zh').value.trim(),
+          en: row.querySelector('.prompt-en').value.trim(),
+        };
+      }).filter(function keepPrompt(prompt) {
+        return prompt.zh || prompt.en;
+      });
+      currentPlan = { prompts };
+      return currentPlan;
+    }
+
+    // Render listing results as one output wall and move each Kimi prompt onto the product image.
+    function renderPromptGroups(groups) {
+      const grid = document.getElementById('resultsGrid');
+      if (!groups || groups.length === 0) {
+        renderResults([]);
+        return;
+      }
+      const products = [];
+      let groupIndex = 0;
+      while (groupIndex < groups.length) {
+        const group = groups[groupIndex];
+        const groupResults = group.results || [];
+        const promptText = `${group.prompt || ''}${group.prompt_en ? ` / ${group.prompt_en}` : ''}`;
+        let resultIndex = 0;
+        while (resultIndex < groupResults.length) {
+          products.push(Object.assign({}, groupResults[resultIndex], { bundle_tag: promptText }));
+          resultIndex += 1;
+        }
+        groupIndex += 1;
+      }
+      renderResults(products);
+    }
+
+    // Request one pure listing search.
+    async function runSearch() {
+      const query = document.getElementById('queryInput').value.trim();
+      const topK = 24;
+      const minPrice = document.getElementById('minPrice').value.trim();
+      const maxPrice = document.getElementById('maxPrice').value.trim();
+      if (!query) {
+        document.getElementById('status').textContent = '先输入 listing/prompt';
+        return;
+      }
+      const button = document.getElementById('searchButton');
+      button.disabled = true;
+      button.textContent = '检索中…';
+      document.getElementById('planPanel').classList.remove('visible');
+      document.getElementById('status').textContent = '正在查纯 listing 索引…';
+      try {
+        const form = new FormData();
+        form.append('query', query);
+        form.append('top_k', String(topK));
+        if (minPrice !== '') form.append('min_price', minPrice);
+        if (maxPrice !== '') form.append('max_price', maxPrice);
+        const startedAt = performance.now();
+        const response = await fetch(`${apiBase}/api/search/text`, { method: 'POST', body: form });
+        const data = await response.json();
+        if (!response.ok || data.error) throw new Error(data.error || '检索失败');
+        renderResults(data.results || []);
+        document.getElementById('status').textContent = `${(data.results || []).length} 条 · ${Math.round(performance.now() - startedAt)} ms`;
+      } catch (error) {
+        document.getElementById('resultsGrid').innerHTML = `<div class="empty"><div><strong>检索失败</strong><span>${escapeHtml(error.message)}</span></div></div>`;
+        document.getElementById('status').textContent = '不可用';
+      } finally {
+        button.disabled = false;
+        button.textContent = '仅 Listing 检索';
+      }
+    }
+
+    // Search the listing index again with manually edited Kimi prompts.
+    async function runEditedPromptSearch() {
+      const plan = readEditedPlan();
+      const minPrice = document.getElementById('minPrice').value.trim();
+      const maxPrice = document.getElementById('maxPrice').value.trim();
+      if (!plan.prompts.length) {
+        document.getElementById('status').textContent = '先生成或填写 Prompt';
+        return;
+      }
+      const button = document.getElementById('editedPromptButton');
+      button.disabled = true;
+      button.textContent = '检索中…';
+      document.getElementById('status').textContent = '用编辑后 Prompt 查 Listing CLIP…';
+      try {
+        const payload = { prompts: plan.prompts, top_k: 1 };
+        if (minPrice !== '') payload.min_price = Number(minPrice);
+        if (maxPrice !== '') payload.max_price = Number(maxPrice);
+        const startedAt = performance.now();
+        const response = await fetch(`${apiBase}/api/search/prompts`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(payload),
+        });
+        const data = await response.json();
+        if (!response.ok || data.error) throw new Error(data.error || '编辑 Prompt 检索失败');
+        renderPlan(data.plan, (data.results || []).length);
+        renderPromptGroups(data.groups || []);
+        document.getElementById('status').textContent = `${(data.results || []).length} 条 · ${Math.round(performance.now() - startedAt)} ms`;
+      } catch (error) {
+        document.getElementById('resultsGrid').innerHTML = `<div class="empty"><div><strong>编辑 Prompt 检索失败</strong><span>${escapeHtml(error.message)}</span></div></div>`;
+        document.getElementById('status').textContent = '不可用';
+      } finally {
+        button.disabled = false;
+        button.textContent = '用编辑后 Prompt 检索';
+      }
+    }
+
+    // Run the uploaded image through Kimi JSON prompts and pure listing CLIP recall.
+    async function runAssembly() {
+      const topK = 1;
+      const minPrice = document.getElementById('minPrice').value.trim();
+      const maxPrice = document.getElementById('maxPrice').value.trim();
+      const kimiPrompt = document.getElementById('kimiPromptInput').value.trim() || defaultKimiPrompt;
+      if (!selectedFile) {
+        document.getElementById('status').textContent = '先上传图片；Kimi 不读取文本框';
+        return;
+      }
+      const button = document.getElementById('assemblyButton');
+      button.disabled = true;
+      document.getElementById('searchButton').disabled = true;
+      document.getElementById('editedPromptButton').disabled = true;
+      button.textContent = '组货中…';
+      document.getElementById('status').textContent = 'Image -> Kimi -> 组货商品 JSON -> Listing CLIP…';
+      document.getElementById('planPanel').classList.remove('visible');
+      document.getElementById('resultsGrid').innerHTML = '<div class="empty"><div><strong>正在生成组货商品</strong><span>Kimi 完成后会查纯 listing 索引</span></div></div>';
+      try {
+        const form = new FormData();
+        form.append('file', selectedFile);
+        form.append('kimi_prompt', kimiPrompt);
+        form.append('top_k', String(topK));
+        if (minPrice !== '') form.append('min_price', minPrice);
+        if (maxPrice !== '') form.append('max_price', maxPrice);
+        const startedAt = performance.now();
+        const response = await fetch(`${apiBase}/api/assemble`, { method: 'POST', body: form });
+        const data = await response.json();
+        if (!response.ok || data.error) throw new Error(data.error || '组货失败');
+        if (data.kimi_prompt) document.getElementById('kimiPromptInput').value = data.kimi_prompt;
+        renderPlan(data.plan, (data.results || []).length);
+        renderPromptGroups(data.groups || []);
+        document.getElementById('status').textContent = `${(data.results || []).length} 条 · ${Math.round(performance.now() - startedAt)} ms`;
+      } catch (error) {
+        document.getElementById('resultsGrid').innerHTML = `<div class="empty"><div><strong>组货失败</strong><span>${escapeHtml(error.message)}</span></div></div>`;
+        document.getElementById('status').textContent = '组货不可用';
+      } finally {
+        button.disabled = false;
+        document.getElementById('searchButton').disabled = false;
+        document.getElementById('editedPromptButton').disabled = false;
+        button.textContent = '生成 Kimi 组货方案';
+      }
+    }
+
+    // Render only the compact server readiness badge.
+    function renderServerStatus(data) {
+      const kimiStatus = data.kimi_configured ? 'Kimi ready' : 'Kimi key missing';
+      document.getElementById('serverStatus').textContent = `${data.index_exists ? '9990 index ready' : '9990 index pending'} · ${kimiStatus}`;
+    }
+
+    // Poll the server status for the compact readiness badge.
+    async function refreshStatus() {
+      try {
+        const response = await fetch(`${apiBase}/api/index/status`, { cache: 'no-store' });
+        const data = await response.json();
+        renderServerStatus(data);
+      } catch (error) {
+        document.getElementById('serverStatus').textContent = '9990 未启动';
+      }
+    }
+
+    // Handle drag-over feedback for the image drop area.
+    function handleDragOver(event) {
+      event.preventDefault();
+      document.getElementById('dropzone').classList.add('active');
+    }
+
+    // Remove drag-over feedback after the pointer leaves the drop area.
+    function handleDragLeave() {
+      document.getElementById('dropzone').classList.remove('active');
+    }
+
+    // Handle a dropped image file.
+    function handleDrop(event) {
+      event.preventDefault();
+      handleDragLeave();
+      setSelectedFile(event.dataTransfer.files[0]);
+    }
+
+    // Update the selected file when the native file picker changes.
+    function handleFileChange(event) {
+      setSelectedFile(event.target.files[0]);
+    }
+
+    // Search the CLIP text box with Ctrl+Enter.
+    function handleQueryKeydown(event) {
+      if ((event.ctrlKey || event.metaKey) && event.key === 'Enter') runSearch();
+    }
+
+    // Switch the bottom composer between image assembly and direct CLIP search.
+    function switchMode(mode) {
+      const imageMode = document.getElementById('imageMode');
+      const textMode = document.getElementById('textMode');
+      const imageTab = document.getElementById('imageModeTab');
+      const textTab = document.getElementById('textModeTab');
+      const isImageMode = mode === 'image';
+      imageMode.classList.toggle('active', isImageMode);
+      textMode.classList.toggle('active', !isImageMode);
+      imageTab.classList.toggle('active', isImageMode);
+      textTab.classList.toggle('active', !isImageMode);
+    }
+
+    document.getElementById('assemblyButton').addEventListener('click', runAssembly);
+    document.getElementById('searchButton').addEventListener('click', runSearch);
+    document.getElementById('editedPromptButton').addEventListener('click', runEditedPromptSearch);
+    document.getElementById('imageModeTab').addEventListener('click', function activateImageMode() { switchMode('image'); });
+    document.getElementById('textModeTab').addEventListener('click', function activateTextMode() { switchMode('text'); });
+    document.getElementById('queryInput').addEventListener('keydown', handleQueryKeydown);
+    document.getElementById('kimiPromptInput').value = defaultKimiPrompt;
+    document.getElementById('imageInput').addEventListener('change', handleFileChange);
+    document.getElementById('dropzone').addEventListener('dragover', handleDragOver);
+    document.getElementById('dropzone').addEventListener('dragleave', handleDragLeave);
+    document.getElementById('dropzone').addEventListener('drop', handleDrop);
+    setInterval(refreshStatus, 3000);
+    refreshStatus();
+  </script>
+</body>
+</html>

config.example.json

@@ -0,0 +1,9 @@
+{
+  "kimi": {
+    "api_key": "",
+    "endpoint": "https://api.moonshot.cn/v1/chat/completions",
+    "model": "kimi-k2.6",
+    "temperature": 0.6,
+    "max_completion_tokens": 1200
+  }
+}

data/full_clip_index/products_full_prices.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a63876a98e6c4e4341566c90e00b0f4001a62ad69d55c474884e96c5aca141dc
+size 37368003

data/full_listing_index/cleaning_report.json

@@ -0,0 +1,8 @@
+{
+  "source": 286548,
+  "kept": 273454,
+  "dropped_missing": 0,
+  "dropped_short": 7554,
+  "dropped_duplicate": 5540,
+  "updated_at": "2026-08-21 09:13:05"
+}

data/full_listing_index/products_listing.index

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e50a979e2386e24b862bfbd23fb90658ccc60e406e612144808318bde3f631e
+size 560033837

data/full_listing_index/products_listing_meta.runtime.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c10a2a02aab00a382f9b02cc521e11a3225a28bf334fa987e226acf5832767f
+size 139038585

data/full_listing_index/progress.json

@@ -0,0 +1,6 @@
+{
+  "completed": 273454,
+  "total": 273454,
+  "status": "complete",
+  "updated_at": "2026-08-21 09:51:05"
+}

data/yunqi_clip_training/last_checkpoint.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57f6be30140cb9f03fd6d7b7aa83fefc2c4441ef4244608a8391084c0031c35a
+size 692418197

models/open_clip_pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bd3c7172de5b207ceac554f5ab5266166f3b9baccc9af5989bc801016d080ad
+size 605219813

work/build_full_listing_index.py

@@ -0,0 +1,395 @@
+"""Build a cleaned full-product CLIP text index from listing metadata."""
+
+import argparse
+import json
+import os
+import re
+import time
+from pathlib import Path
+
+import faiss
+import numpy as np
+import open_clip
+import torch
+
+
+CLIP_DIR = Path(r"F:\Clip")
+SOURCE_INDEX_DIR = CLIP_DIR / "data" / "full_clip_index"
+SOURCE_METADATA_PATH = SOURCE_INDEX_DIR / "products_full_meta.json"
+PRICE_METADATA_PATH = SOURCE_INDEX_DIR / "products_full_prices.json"
+MODEL_PATH = CLIP_DIR / "models" / "open_clip_pytorch_model.bin"
+CHECKPOINT_PATH = CLIP_DIR / "data" / "yunqi_clip_training" / "last_checkpoint.pt"
+OUTPUT_DIR = CLIP_DIR / "data" / "full_listing_index"
+METADATA_PATH = OUTPUT_DIR / "products_listing_meta.json"
+EMBEDDINGS_PATH = OUTPUT_DIR / "products_listing_embeddings.npy"
+INDEX_PATH = OUTPUT_DIR / "products_listing.index"
+PROGRESS_PATH = OUTPUT_DIR / "progress.json"
+REPORT_PATH = OUTPUT_DIR / "cleaning_report.json"
+MODEL_NAME = "ViT-B-32"
+DEFAULT_BATCH_SIZE = 256
+DEFAULT_SAVE_EVERY = 2048
+
+STOP_WORDS = {
+    "with",
+    "for",
+    "and",
+    "the",
+    "set",
+    "pcs",
+    "piece",
+    "pieces",
+    "pack",
+    "new",
+    "hot",
+    "sale",
+    "best",
+    "high",
+    "quality",
+    "portable",
+    "creative",
+    "fashion",
+    "women",
+    "men",
+    "kids",
+    "girls",
+    "boys",
+    "home",
+    "office",
+    "outdoor",
+    "indoor",
+}
+
+
+def parse_arguments():
+    """Parse options for a resumable listing-index build."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--batch-size", type=int, default=DEFAULT_BATCH_SIZE)
+    parser.add_argument("--save-every", type=int, default=DEFAULT_SAVE_EVERY)
+    parser.add_argument("--force-clean", action="store_true")
+    return parser.parse_args()
+
+
+def write_json_atomic(path, payload):
+    """Write JSON through a temporary file and replace the target atomically."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary_path = path.with_suffix(path.suffix + ".tmp")
+    temporary_path.write_text(
+        json.dumps(payload, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+    last_error = None
+    attempt = 0
+    while attempt < 10:
+        try:
+            os.replace(temporary_path, path)
+            return
+        except PermissionError as error:
+            last_error = error
+            time.sleep(0.5)
+        attempt += 1
+    raise last_error
+
+
+def clean_spaces(value):
+    """Collapse noisy whitespace and remove invisible control characters."""
+    text = str(value or "").replace("\u0000", " ")
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+
+def looks_mojibake(value):
+    """Detect obviously broken text so English listing can be preferred."""
+    text = str(value or "")
+    if not text:
+        return False
+    bad_count = 0
+    for character in text:
+        if character == "�":
+            bad_count += 1
+    return bad_count >= max(3, len(text) // 12)
+
+
+def choose_listing_text(record):
+    """Choose the cleanest searchable listing text from one product record."""
+    title_en = clean_spaces(record.get("title_en", ""))
+    title_cn = clean_spaces(record.get("title_cn", ""))
+    title = clean_spaces(record.get("title", ""))
+    if title_en:
+        return title_en
+    if title and not looks_mojibake(title):
+        return title
+    if title_cn and not looks_mojibake(title_cn):
+        return title_cn
+    return title_en or title or title_cn
+
+
+def normalize_for_exact_dedupe(value):
+    """Build a strict title key for exact duplicate removal."""
+    text = clean_spaces(value).lower()
+    text = re.sub(r"[^a-z0-9]+", " ", text)
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+
+def make_family_key(value):
+    """Build a coarse key used later to avoid same-looking Top results."""
+    normalized = normalize_for_exact_dedupe(value)
+    tokens = normalized.split(" ")
+    kept_tokens = []
+    for token in tokens:
+        if len(token) <= 2:
+            continue
+        if token in STOP_WORDS:
+            continue
+        if token.isdigit():
+            continue
+        kept_tokens.append(token)
+    unique_tokens = []
+    for token in kept_tokens:
+        if token not in unique_tokens:
+            unique_tokens.append(token)
+    if len(unique_tokens) <= 2:
+        return normalized[:80]
+    return " ".join(unique_tokens[:10])
+
+
+def load_source_products():
+    """Load the existing full product metadata generated by the image index."""
+    if not SOURCE_METADATA_PATH.exists():
+        raise FileNotFoundError(f"Missing source metadata: {SOURCE_METADATA_PATH}")
+    return json.loads(SOURCE_METADATA_PATH.read_text(encoding="utf-8"))
+
+
+def clean_products(raw_products):
+    """Drop unusable listings and exact duplicate listing records."""
+    cleaned_products = []
+    seen_titles = set()
+    seen_ids = set()
+    dropped_short = 0
+    dropped_duplicate = 0
+    dropped_missing = 0
+    for raw_product in raw_products:
+        product_id = str(raw_product.get("id", "")).strip()
+        listing_text = choose_listing_text(raw_product)
+        exact_key = normalize_for_exact_dedupe(listing_text)
+        if not product_id or not listing_text:
+            dropped_missing += 1
+            continue
+        if len(exact_key) < 8:
+            dropped_short += 1
+            continue
+        if product_id in seen_ids or exact_key in seen_titles:
+            dropped_duplicate += 1
+            continue
+        product = raw_product.copy()
+        product["title"] = listing_text
+        product["listing_text"] = listing_text
+        product["listing_key"] = exact_key
+        product["family_key"] = make_family_key(listing_text)
+        product["img_url"] = f"/listing-images/{product_id}.jpg"
+        cleaned_products.append(product)
+        seen_ids.add(product_id)
+        seen_titles.add(exact_key)
+    report = {
+        "source": len(raw_products),
+        "kept": len(cleaned_products),
+        "dropped_missing": dropped_missing,
+        "dropped_short": dropped_short,
+        "dropped_duplicate": dropped_duplicate,
+        "updated_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+    }
+    return cleaned_products, report
+
+
+def load_or_create_clean_products(force_clean):
+    """Reuse cleaned metadata unless a fresh cleaning pass is requested."""
+    if METADATA_PATH.exists() and not force_clean:
+        return json.loads(METADATA_PATH.read_text(encoding="utf-8"))
+    raw_products = load_source_products()
+    cleaned_products, report = clean_products(raw_products)
+    write_json_atomic(METADATA_PATH, cleaned_products)
+    write_json_atomic(REPORT_PATH, report)
+    return cleaned_products
+
+
+def load_model():
+    """Load the trained CLIP text tower on CPU."""
+    if not MODEL_PATH.exists():
+        raise FileNotFoundError(f"Missing base model: {MODEL_PATH}")
+    if not CHECKPOINT_PATH.exists():
+        raise FileNotFoundError(f"Missing trained checkpoint: {CHECKPOINT_PATH}")
+    device = torch.device("cpu")
+    model, _, _ = open_clip.create_model_and_transforms(
+        MODEL_NAME,
+        pretrained=str(MODEL_PATH),
+    )
+    checkpoint = torch.load(CHECKPOINT_PATH, map_location=device, weights_only=False)
+    model.load_state_dict(checkpoint["model"])
+    model = model.to(device)
+    model.eval()
+    tokenizer = open_clip.get_tokenizer(MODEL_NAME)
+    return model, tokenizer, device
+
+
+def load_progress(total):
+    """Read the last completed text embedding count for resume."""
+    if not PROGRESS_PATH.exists():
+        return 0
+    progress = json.loads(PROGRESS_PATH.read_text(encoding="utf-8"))
+    if int(progress.get("total", total)) != total:
+        raise RuntimeError("Existing listing progress does not match cleaned metadata")
+    return max(0, min(total, int(progress.get("completed", 0))))
+
+
+def open_embedding_memmap(total, dimension):
+    """Create or reopen the text embedding memmap."""
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    if EMBEDDINGS_PATH.exists():
+        embedding_matrix = np.lib.format.open_memmap(EMBEDDINGS_PATH, mode="r+")
+        if embedding_matrix.shape != (total, dimension):
+            raise RuntimeError("Existing listing embedding matrix shape mismatch")
+        return embedding_matrix
+    return np.lib.format.open_memmap(
+        EMBEDDINGS_PATH,
+        mode="w+",
+        dtype="float32",
+        shape=(total, dimension),
+    )
+
+
+def restore_faiss_index(embedding_matrix, completed, dimension):
+    """Rebuild an in-memory FAISS index from completed text vectors."""
+    index = faiss.IndexFlatIP(dimension)
+    chunk_size = 8192
+    start_index = 0
+    while start_index < completed:
+        end_index = min(start_index + chunk_size, completed)
+        index.add(np.asarray(embedding_matrix[start_index:end_index], dtype="float32"))
+        start_index = end_index
+    return index
+
+
+def write_faiss_index_file(index, path):
+    """Write a FAISS index through Python bytes so Windows Unicode paths stay valid."""
+    serialized_index = faiss.serialize_index(index)
+    path.write_bytes(serialized_index.tobytes())
+
+
+def encode_text_batch(model, tokenizer, texts, device):
+    """Encode one batch of listing strings with the trained text tower."""
+    tokens = tokenizer(texts).to(device)
+    with torch.inference_mode():
+        features = model.encode_text(tokens)
+        features = features / features.norm(dim=-1, keepdim=True)
+    return features.cpu().numpy().astype("float32")
+
+
+def encode_products(products, model, tokenizer, device, batch_size, save_every):
+    """Encode cleaned listings and print live throughput."""
+    dimension = int(model.text_projection.shape[1])
+    total = len(products)
+    completed = load_progress(total)
+    embedding_matrix = open_embedding_memmap(total, dimension)
+    index = restore_faiss_index(embedding_matrix, completed, dimension)
+    started_at = time.perf_counter()
+    while completed < total:
+        batch_end = min(completed + batch_size, total)
+        texts = []
+        product_index = completed
+        while product_index < batch_end:
+            texts.append(products[product_index]["listing_text"])
+            product_index += 1
+        batch_features = encode_text_batch(model, tokenizer, texts, device)
+        embedding_matrix[completed:batch_end] = batch_features
+        index.add(batch_features)
+        completed = batch_end
+        if completed % save_every < batch_size or completed >= total:
+            embedding_matrix.flush()
+            write_json_atomic(
+                PROGRESS_PATH,
+                {
+                    "completed": completed,
+                    "total": total,
+                    "status": "building",
+                    "updated_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+                },
+            )
+        elapsed = time.perf_counter() - started_at
+        rate = completed / max(elapsed, 1e-6)
+        eta_minutes = (total - completed) / max(rate, 1e-6) / 60
+        print(
+            "listing_embedding",
+            completed,
+            "/",
+            total,
+            "rate",
+            f"{rate:.2f}/s",
+            "eta_minutes",
+            f"{eta_minutes:.1f}",
+            flush=True,
+        )
+    return embedding_matrix, index
+
+
+def write_final_outputs(products, embedding_matrix, index):
+    """Publish the finished listing index without touching the image index."""
+    embedding_matrix.flush()
+    temporary_index_path = INDEX_PATH.with_suffix(INDEX_PATH.suffix + ".tmp")
+    write_faiss_index_file(index, temporary_index_path)
+    os.replace(temporary_index_path, INDEX_PATH)
+    write_json_atomic(METADATA_PATH, products)
+    write_json_atomic(
+        PROGRESS_PATH,
+        {
+            "completed": len(products),
+            "total": len(products),
+            "status": "complete",
+            "updated_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        },
+    )
+    return index.ntotal
+
+
+def main():
+    """Run the full cleaned listing-index build."""
+    arguments = parse_arguments()
+    products = load_or_create_clean_products(arguments.force_clean)
+    model, tokenizer, device = load_model()
+    print(
+        "listing_index_start",
+        json.dumps(
+            {
+                "device": str(device),
+                "products": len(products),
+                "batch_size": arguments.batch_size,
+                "output_dir": str(OUTPUT_DIR),
+            },
+            ensure_ascii=False,
+        ),
+        flush=True,
+    )
+    embedding_matrix, index = encode_products(
+        products,
+        model,
+        tokenizer,
+        device,
+        max(1, arguments.batch_size),
+        max(1, arguments.save_every),
+    )
+    vector_count = write_final_outputs(products, embedding_matrix, index)
+    print(
+        "listing_index_complete",
+        json.dumps(
+            {
+                "vectors": vector_count,
+                "dimension": int(embedding_matrix.shape[1]),
+                "index": str(INDEX_PATH),
+            },
+            ensure_ascii=False,
+        ),
+        flush=True,
+    )
+
+
+if __name__ == "__main__":
+    main()

work/full_clip_server.py

@@ -0,0 +1,615 @@
+"""Serve the full trained CLIP index and Kimi assembly planner."""
+
+import base64
+import io
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from urllib.parse import urlparse
+
+import faiss
+import numpy as np
+import open_clip
+import torch
+from fastapi import FastAPI, File, Form, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+from PIL import Image
+import uvicorn
+
+
+APP_ROOT = Path(__file__).resolve().parent.parent
+BUNDLED_FULL_INDEX_DIR = APP_ROOT / "data" / "full_clip_index"
+BUNDLED_MODEL_PATH = APP_ROOT / "models" / "open_clip_pytorch_model.bin"
+CLIP_DIR = APP_ROOT if BUNDLED_FULL_INDEX_DIR.exists() and BUNDLED_MODEL_PATH.exists() else Path(r"F:\Clip")
+FULL_INDEX_DIR = CLIP_DIR / "data" / "full_clip_index"
+INDEX_PATH = FULL_INDEX_DIR / "products_full.index"
+METADATA_PATH = FULL_INDEX_DIR / "products_full_meta.json"
+PRICE_METADATA_PATH = FULL_INDEX_DIR / "products_full_prices.json"
+PROGRESS_PATH = FULL_INDEX_DIR / "progress.json"
+IMAGE_DIR = APP_ROOT / "images"
+BASE_MODEL_PATH = CLIP_DIR / "models" / "open_clip_pytorch_model.bin"
+TRAINED_CHECKPOINT_PATH = CLIP_DIR / "data" / "yunqi_clip_training" / "last_checkpoint.pt"
+HTML_PATH = APP_ROOT / "app" / "clip_search.html" if (APP_ROOT / "app" / "clip_search.html").exists() else APP_ROOT / "clip_search.html"
+MODEL_NAME = "ViT-B-32"
+CONFIG_PATH = APP_ROOT / "config.json"
+KIMI_API_KEY_ENV = "MOONSHOT_API_KEY"
+KIMI_ENDPOINT_ENV = "KIMI_ENDPOINT"
+KIMI_MODEL_ENV = "KIMI_MODEL"
+APP_CONFIG = {}
+KIMI_CONFIG = {}
+KIMI_API_URL = "https://api.moonshot.cn/v1/chat/completions"
+KIMI_MODEL = "kimi-k2.6"
+KIMI_TEMPERATURE = 0.6
+KIMI_MAX_COMPLETION_TOKENS = 1800
+
+
+def load_app_config():
+    """Load local app configuration without committing user secrets."""
+    if not CONFIG_PATH.exists():
+        return {}
+    return json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+
+
+def read_kimi_config():
+    """Return Kimi API settings from environment variables, config.json, and defaults."""
+    config = APP_CONFIG.get("kimi", {}) if isinstance(APP_CONFIG, dict) else {}
+    return {
+        "api_key": os.environ.get(KIMI_API_KEY_ENV, "").strip() or str(config.get("api_key", "")).strip(),
+        "endpoint": os.environ.get(KIMI_ENDPOINT_ENV, "").strip() or str(config.get("endpoint", KIMI_API_URL)).strip(),
+        "model": os.environ.get(KIMI_MODEL_ENV, "").strip() or str(config.get("model", KIMI_MODEL)).strip(),
+        "temperature": float(config.get("temperature", KIMI_TEMPERATURE)),
+        "max_completion_tokens": int(config.get("max_completion_tokens", KIMI_MAX_COMPLETION_TOKENS)),
+    }
+
+
+APP_CONFIG = load_app_config()
+KIMI_CONFIG = read_kimi_config()
+KIMI_API_URL = KIMI_CONFIG["endpoint"]
+KIMI_MODEL = KIMI_CONFIG["model"]
+KIMI_TEMPERATURE = KIMI_CONFIG["temperature"]
+KIMI_MAX_COMPLETION_TOKENS = KIMI_CONFIG["max_completion_tokens"]
+
+
+def read_faiss_index_file(path):
+    """Read a FAISS index through Python bytes so Windows Unicode paths stay valid."""
+    index_bytes = np.frombuffer(path.read_bytes(), dtype="uint8")
+    return faiss.deserialize_index(index_bytes)
+
+
+def load_runtime():
+    """Load the completed full FAISS index, metadata, and trained CLIP model."""
+    if not INDEX_PATH.exists() or not METADATA_PATH.exists():
+        raise FileNotFoundError("全量索引尚未生成完成")
+    if PROGRESS_PATH.exists():
+        progress = json.loads(PROGRESS_PATH.read_text(encoding="utf-8"))
+        if progress.get("status") != "complete":
+            raise RuntimeError(
+                f"全量索引仍在构建：{progress.get('completed', 0)}/{progress.get('total', 0)}"
+            )
+    if not BASE_MODEL_PATH.exists() or not TRAINED_CHECKPOINT_PATH.exists():
+        raise FileNotFoundError("基础模型或最终训练 checkpoint 不存在")
+    device = torch.device("cpu")
+    model, _, preprocess = open_clip.create_model_and_transforms(
+        MODEL_NAME,
+        pretrained=str(BASE_MODEL_PATH),
+    )
+    checkpoint = torch.load(TRAINED_CHECKPOINT_PATH, map_location=device, weights_only=False)
+    model.load_state_dict(checkpoint["model"])
+    model = model.to(device)
+    model.eval()
+    index = read_faiss_index_file(INDEX_PATH)
+    products = json.loads(METADATA_PATH.read_text(encoding="utf-8"))
+    price_metadata = {}
+    if PRICE_METADATA_PATH.exists():
+        price_metadata = json.loads(PRICE_METADATA_PATH.read_text(encoding="utf-8"))
+    if index.ntotal != len(products):
+        raise RuntimeError(f"索引数量 {index.ntotal} 与元数据数量 {len(products)} 不一致")
+    tokenizer = open_clip.get_tokenizer(MODEL_NAME)
+    return model, preprocess, tokenizer, device, index, products, price_metadata
+
+
+def get_rank_window(top_k):
+    """Clamp the requested result count to a safe full-index range."""
+    return max(1, min(int(top_k), 100))
+
+
+def encode_image(image, model, preprocess, device):
+    """Encode one uploaded image with the trained CLIP image tower."""
+    tensor = preprocess(image.convert("RGB")).unsqueeze(0).to(device)
+    with torch.inference_mode():
+        feature = model.encode_image(tensor)
+        feature = feature / feature.norm(dim=-1, keepdim=True)
+    return feature.cpu().numpy().astype("float32")
+
+
+def encode_text(query, model, tokenizer, device):
+    """Encode one prompt with the trained CLIP text tower."""
+    tokens = tokenizer([query]).to(device)
+    with torch.inference_mode():
+        feature = model.encode_text(tokens)
+        feature = feature / feature.norm(dim=-1, keepdim=True)
+    return feature.cpu().numpy().astype("float32")
+
+
+def search_index(
+    query_vector,
+    top_k,
+    index,
+    products,
+    price_metadata,
+    min_price=None,
+    max_price=None,
+):
+    """Search FAISS and apply an optional price constraint before returning Top K."""
+    output_count = get_rank_window(top_k)
+    search_count = index.ntotal if min_price is not None or max_price is not None else output_count
+    scores, indices = index.search(query_vector, search_count)
+    results = []
+    for result_position in range(len(indices[0])):
+        product_index = int(indices[0][result_position])
+        if product_index < 0 or product_index >= len(products):
+            continue
+        product = products[product_index].copy()
+        product["similarity"] = round(float(scores[0][result_position]) * 100, 2)
+        product["img_url"] = f"/images/{product['id']}.jpg"
+        product_id = str(product["id"])
+        if product_id in price_metadata:
+            product.update(price_metadata[product_id])
+        if min_price is not None or max_price is not None:
+            price = product.get("price_usd")
+            if price is None:
+                continue
+            if min_price is not None and float(price) < float(min_price):
+                continue
+            if max_price is not None and float(price) > float(max_price):
+                continue
+        product["rank"] = len(results) + 1
+        results.append(product)
+        if len(results) >= output_count:
+            break
+    return results
+
+
+def resolve_image_from_request(file, img_url):
+    """Read an uploaded image or an allowed local image URL into PIL."""
+    if isinstance(file, (bytes, bytearray)) and file:
+        return Image.open(io.BytesIO(file)).convert("RGB")
+    if file and file.filename:
+        return Image.open(io.BytesIO(file)).convert("RGB")
+    if img_url:
+        parsed_url = urlparse(img_url)
+        local_name = os.path.basename(parsed_url.path)
+        local_path = IMAGE_DIR / local_name
+        if parsed_url.path.startswith("/images/") and local_path.exists():
+            return Image.open(local_path).convert("RGB")
+    raise ValueError("没有提供有效图片")
+
+
+def merge_search_results(image_results, text_results, image_weight):
+    """Merge image and listing search results by product ID and CLIP score."""
+    result_by_id = {}
+    text_weight = 1.0 - image_weight
+    for product in image_results:
+        product_id = str(product.get("id", ""))
+        item = product.copy()
+        item["image_similarity"] = float(product.get("similarity", 0.0))
+        item["text_similarity"] = 0.0
+        result_by_id[product_id] = item
+    for product in text_results:
+        product_id = str(product.get("id", ""))
+        if product_id not in result_by_id:
+            item = product.copy()
+            item["image_similarity"] = 0.0
+            item["text_similarity"] = float(product.get("similarity", 0.0))
+            result_by_id[product_id] = item
+        else:
+            result_by_id[product_id]["text_similarity"] = float(product.get("similarity", 0.0))
+    results = []
+    for item in result_by_id.values():
+        item["similarity"] = round(
+            item["image_similarity"] * image_weight
+            + item["text_similarity"] * text_weight,
+            2,
+        )
+        results.append(item)
+    index = 0
+    while index < len(results):
+        best_index = index
+        candidate_index = index + 1
+        while candidate_index < len(results):
+            if results[candidate_index]["similarity"] > results[best_index]["similarity"]:
+                best_index = candidate_index
+            candidate_index += 1
+        if best_index != index:
+            results[index], results[best_index] = results[best_index], results[index]
+        results[index]["rank"] = index + 1
+        index += 1
+    return results
+
+
+def filter_by_price(products, min_price, max_price):
+    """Keep products inside the requested USD price range."""
+    if min_price is None and max_price is None:
+        return products
+    filtered = []
+    for product in products:
+        price = product.get("price_usd")
+        if price is None:
+            continue
+        if min_price is not None and float(price) < float(min_price):
+            continue
+        if max_price is not None and float(price) > float(max_price):
+            continue
+        filtered.append(product)
+    return filtered
+
+
+def image_to_data_url(image):
+    """Resize an input image and encode it as a compact Kimi data URL."""
+    image_copy = image.copy().convert("RGB")
+    image_copy.thumbnail((1280, 1280))
+    image_buffer = io.BytesIO()
+    image_copy.save(image_buffer, format="JPEG", quality=85, optimize=True)
+    encoded = base64.b64encode(image_buffer.getvalue()).decode("ascii")
+    return f"data:image/jpeg;base64,{encoded}"
+
+
+def build_clip_evidence(image, listing, model, preprocess, tokenizer, device, index, products, price_metadata):
+    """Collect weak CLIP evidence so Kimi can correct noisy retrieval signals."""
+    evidence = []
+    if image is not None:
+        image_vector = encode_image(image, model, preprocess, device)
+        image_results = search_index(image_vector, 8, index, products, price_metadata)
+        evidence.append({"source": "image", "results": image_results})
+    if listing:
+        listing_vector = encode_text(listing, model, tokenizer, device)
+        listing_results = search_index(listing_vector, 8, index, products, price_metadata)
+        evidence.append({"source": "listing", "results": listing_results})
+    return evidence
+
+
+def call_kimi(image, listing, min_price, max_price, clip_evidence):
+    """Call domestic Kimi K2.6 in JSON and non-thinking mode."""
+    api_key = KIMI_CONFIG["api_key"]
+    if not api_key:
+        raise RuntimeError(f"未配置 {CONFIG_PATH.name} 里的 kimi.api_key 或 {KIMI_API_KEY_ENV} 环境变量")
+    price_rule = {
+        "currency": "USD",
+        "min": min_price,
+        "max": max_price,
+    }
+    system_prompt = (
+        "你是商品组货规划助手，不是单纯的相似商品检索器。"
+        "请根据输入图片和Listing生成10个用于商品向量检索的中英文Prompt，目标是找出可以一起销售或一起购买的一组商品。"
+        "CLIP召回结果不够精准，只能作为弱证据，禁止直接照抄CLIP误召回的品类。"
+        "10个Prompt必须发散到不同组货方向，不能只是同一商品的颜色、材质或包装改写。"
+        "10个方向依次覆盖：1核心相似品，2功能替代品，3互补配件，4共同使用工具，5配套耗材，6高概率一起购买的关联品，7收纳整理品，8包装展示品，9人群场景关联品，10套装组合方案。"
+        "互补品必须和主商品的使用场景有明确关系，不要生成无关的氛围用品。"
+        "例如主商品是扳手，可以发散到锤子、螺丝刀、卷尺、螺丝螺母、工具收纳包，而不是只生成不同颜色的扳手。"
+        "Listing明确写出的品类优先；图片用于确认外观、颜色、形状和材质。"
+        "如果图片和Listing明显冲突，内部自行纠偏，并优先保留Listing主品类。"
+        "只能返回合法JSON对象，且只能有一个字段 prompts。"
+        "prompts 必须是长度为10的数组，数组元素只能是对象，且只能包含 zh 和 en 两个字段。"
+        "zh 是简短具体的中文检索词，en 是语义完全一致的英文检索词。"
+        "不要返回plan_name、summary、role、reason、price_filter、input_conflict或clip_adjustment。"
+    )
+    user_text = (
+        "输入Listing:\n"
+        + (listing or "未提供")
+        + "\n价格筛选（美元）:\n"
+        + json.dumps(price_rule, ensure_ascii=False)
+        + "\nCLIP弱证据（可能不准确，只用于发现偏差）:\n"
+        + json.dumps(clip_evidence, ensure_ascii=False)
+        + "\n请只返回JSON对象，不要Markdown代码围栏。"
+    )
+    content = [{"type": "text", "text": user_text}]
+    if image is not None:
+        content.insert(
+            0,
+            {
+                "type": "image_url",
+                "image_url": {"url": image_to_data_url(image)},
+            },
+        )
+    payload = {
+        "model": KIMI_MODEL,
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": content},
+        ],
+        "thinking": {"type": "disabled"},
+        "temperature": KIMI_TEMPERATURE,
+        "response_format": {"type": "json_object"},
+        "max_completion_tokens": KIMI_MAX_COMPLETION_TOKENS,
+    }
+    request = urllib.request.Request(
+        KIMI_API_URL,
+        data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        method="POST",
+    )
+    response_data = None
+    attempt = 0
+    while attempt < 3:
+        try:
+            with urllib.request.urlopen(request, timeout=120) as response:
+                response_data = json.loads(response.read().decode("utf-8"))
+            break
+        except urllib.error.HTTPError as error:
+            detail = error.read().decode("utf-8", errors="replace")
+            retryable = error.code in (429, 500, 502, 503, 504)
+            if not retryable or attempt >= 2:
+                raise RuntimeError(
+                    f"Kimi API HTTP {error.code}: {detail[:500]}"
+                ) from error
+            retry_after = error.headers.get("Retry-After")
+            try:
+                delay = float(retry_after) if retry_after else 2.0 + attempt * 2.0
+            except (TypeError, ValueError):
+                delay = 2.0 + attempt * 2.0
+            time.sleep(min(max(delay, 1.0), 10.0))
+            attempt += 1
+        except urllib.error.URLError as error:
+            if attempt >= 2:
+                raise RuntimeError(f"Kimi API 网络错误: {error.reason}") from error
+            time.sleep(2.0 + attempt * 2.0)
+            attempt += 1
+    choices = response_data.get("choices", [])
+    if not choices:
+        raise RuntimeError("Kimi API 没有返回 choices")
+    content_text = choices[0].get("message", {}).get("content", "")
+    if isinstance(content_text, dict):
+        return content_text
+    try:
+        return json.loads(content_text)
+    except (TypeError, json.JSONDecodeError) as error:
+        raise RuntimeError("Kimi 返回内容不是合法 JSON") from error
+
+
+def normalize_kimi_prompts(raw_plan, listing, min_price, max_price):
+    """Validate Kimi prompts and fill missing prompts without inventing products."""
+    raw_prompts = raw_plan.get("prompts", []) if isinstance(raw_plan, dict) else []
+    if not isinstance(raw_prompts, list):
+        raw_prompts = []
+    prompts = []
+    default_roles = [
+        "核心相似品",
+        "功能替代品",
+        "互补配件",
+        "共同使用工具",
+        "配套耗材",
+        "关联加购品",
+        "收纳整理品",
+        "包装展示品",
+        "人群场景关联品",
+        "场景套装/收纳方案",
+    ]
+    for raw_prompt in raw_prompts:
+        if isinstance(raw_prompt, dict):
+            prompt_text = str(
+                raw_prompt.get("zh", raw_prompt.get("prompt", ""))
+            ).strip()
+            prompt_english = str(
+                raw_prompt.get("en", raw_prompt.get("prompt_en", ""))
+            ).strip()
+            prompt_role = raw_prompt.get(
+                "role",
+                default_roles[min(len(prompts), len(default_roles) - 1)],
+            )
+            prompt_reason = raw_prompt.get("reason", "适合图片和Listing检索")
+        else:
+            prompt_text = str(raw_prompt).strip()
+            prompt_english = ""
+            prompt_role = default_roles[min(len(prompts), len(default_roles) - 1)]
+            prompt_reason = "适合图片和Listing检索"
+        if not prompt_text:
+            continue
+        prompts.append(
+            {
+                "prompt": prompt_text,
+                "prompt_en": prompt_english,
+                "role": prompt_role,
+                "reason": prompt_reason,
+            }
+        )
+        if len(prompts) >= 10:
+            break
+    fallback_text = listing.strip() or "符合输入图片风格的商品"
+    fallback_roles = [
+        "核心相似品",
+        "功能替代品",
+        "互补配件",
+        "共同使用工具",
+        "配套耗材",
+        "关联加购品",
+        "收纳整理品",
+        "包装展示品",
+        "人群场景关联品",
+        "场景套装/收纳方案",
+    ]
+    index = 0
+    while len(prompts) < 10:
+        prompts.append(
+            {
+                "prompt": f"{fallback_text}，{fallback_roles[index]}",
+                "prompt_en": "",
+                "role": fallback_roles[index],
+                "reason": "Kimi未返回足够Prompt，使用Listing补足检索方向",
+            }
+        )
+        index += 1
+    return {"prompts": prompts}
+
+
+def create_app():
+    """Load runtime assets and create the FastAPI application."""
+    model, preprocess, tokenizer, device, index, products, price_metadata = load_runtime()
+    application = FastAPI(title="Full CLIP Product Search")
+    application.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    if IMAGE_DIR.exists():
+        application.mount("/images", StaticFiles(directory=IMAGE_DIR), name="images")
+
+    @application.post("/api/search/image")
+    async def search_image(
+        file: UploadFile = File(None),
+        img_url: str = Form(None),
+        top_k: int = Form(12),
+    ):
+        """Search full product metadata using an uploaded image."""
+        try:
+            contents = await file.read() if file and file.filename else None
+            image = resolve_image_from_request(contents, img_url)
+            query_vector = encode_image(image, model, preprocess, device)
+            return {"results": search_index(query_vector, top_k, index, products, price_metadata)}
+        except Exception as error:
+            return JSONResponse({"error": str(error)}, status_code=400)
+
+    @application.post("/api/search/text")
+    async def search_text(
+        query: str = Form(...),
+        top_k: int = Form(12),
+    ):
+        """Search full product metadata using a text prompt."""
+        try:
+            query_vector = encode_text(query, model, tokenizer, device)
+            return {"results": search_index(query_vector, top_k, index, products, price_metadata)}
+        except Exception as error:
+            return JSONResponse({"error": str(error)}, status_code=400)
+
+    @application.post("/api/assemble")
+    async def assemble_products(
+        file: UploadFile = File(None),
+        listing: str = Form(""),
+        min_price: float = Form(None),
+        max_price: float = Form(None),
+        top_k: int = Form(1),
+    ):
+        """Generate ten Kimi prompts and retrieve one product for each direction."""
+        try:
+            contents = await file.read() if file and file.filename else None
+            image = resolve_image_from_request(contents, "") if contents else None
+            if image is None and not listing.strip():
+                raise ValueError("请至少提供图片或 Listing")
+            clip_evidence = build_clip_evidence(
+                image,
+                listing.strip(),
+                model,
+                preprocess,
+                tokenizer,
+                device,
+                index,
+                products,
+                price_metadata,
+            )
+            raw_plan = call_kimi(
+                image,
+                listing.strip(),
+                min_price,
+                max_price,
+                clip_evidence,
+            )
+            plan = normalize_kimi_prompts(
+                raw_plan,
+                listing,
+                min_price,
+                max_price,
+            )
+            groups = []
+            selected_results = []
+            public_prompts = []
+            prompt_index = 0
+            while prompt_index < len(plan["prompts"]):
+                prompt_item = plan["prompts"][prompt_index]
+                prompt_text = prompt_item["prompt"]
+                prompt_english = prompt_item.get("prompt_en", "").strip()
+                public_prompts.append(
+                    {"zh": prompt_text, "en": prompt_english}
+                )
+                recall_text = prompt_english or prompt_text
+                prompt_vector = encode_text(recall_text, model, tokenizer, device)
+                prompt_matches = search_index(
+                    prompt_vector,
+                    100,
+                    index,
+                    products,
+                    price_metadata,
+                    min_price,
+                    max_price,
+                )
+                price_matches = prompt_matches
+                group_results = []
+                result_index = 0
+                while result_index < min(1, len(price_matches)):
+                    selected = price_matches[result_index].copy()
+                    selected["prompt_index"] = prompt_index + 1
+                    selected["search_prompt"] = prompt_text
+                    selected["search_prompt_en"] = prompt_english
+                    selected["prompt_role"] = prompt_item["role"]
+                    selected["prompt_reason"] = prompt_item["reason"]
+                    selected["prompt_rank"] = result_index + 1
+                    group_results.append(selected)
+                    selected_results.append(selected)
+                    result_index += 1
+                groups.append(
+                    {
+                        "prompt_index": prompt_index + 1,
+                        "prompt": prompt_text,
+                        "prompt_en": prompt_english,
+                        "role": prompt_item["role"],
+                        "reason": prompt_item["reason"],
+                        "results": group_results,
+                    }
+                )
+                prompt_index += 1
+            return {
+                "plan": {"prompts": public_prompts},
+                "results": selected_results,
+                "groups": groups,
+                "prompts_searched": len(groups),
+                "results_per_prompt": 1,
+                "model": KIMI_MODEL,
+                "thinking": "disabled",
+            }
+        except Exception as error:
+            return JSONResponse({"error": str(error)}, status_code=400)
+
+    @application.get("/api/index/status")
+    async def index_status():
+        """Return the loaded full-index count for a quick browser health check."""
+        return {
+            "vectors": index.ntotal,
+            "products": len(products),
+            "price_records": len(price_metadata),
+            "device": str(device),
+            "checkpoint": str(TRAINED_CHECKPOINT_PATH),
+            "kimi_model": KIMI_MODEL,
+            "kimi_configured": bool(KIMI_CONFIG["api_key"]),
+        }
+
+    @application.get("/", response_class=HTMLResponse)
+    async def search_page():
+        """Serve the standalone image and prompt search page."""
+        return HTMLResponse(HTML_PATH.read_text(encoding="utf-8"))
+
+    return application
+
+
+app = create_app()
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8888)

work/full_listing_server.py

@@ -0,0 +1,951 @@
+"""Provide the cleaned pure-listing CLIP index for the integrated worker."""
+
+import base64
+import asyncio
+import concurrent.futures
+import io
+import json
+import os
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+import faiss
+import numpy as np
+import open_clip
+import torch
+from fastapi import Body, FastAPI, File, Form, Request, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse, Response
+from fastapi.staticfiles import StaticFiles
+from PIL import Image
+import uvicorn
+
+
+APP_ROOT = Path(__file__).resolve().parent.parent
+BUNDLED_INDEX_DIR = APP_ROOT / "data" / "full_listing_index"
+BUNDLED_MODEL_PATH = APP_ROOT / "models" / "open_clip_pytorch_model.bin"
+CLIP_DIR = APP_ROOT if BUNDLED_INDEX_DIR.exists() and BUNDLED_MODEL_PATH.exists() else Path(r"F:\Clip")
+LISTING_INDEX_DIR = CLIP_DIR / "data" / "full_listing_index"
+INDEX_PATH = LISTING_INDEX_DIR / "products_listing.index"
+METADATA_PATH = LISTING_INDEX_DIR / "products_listing_meta.json"
+RUNTIME_METADATA_PATH = LISTING_INDEX_DIR / "products_listing_meta.runtime.json"
+PRICE_METADATA_PATH = CLIP_DIR / "data" / "full_clip_index" / "products_full_prices.json"
+PROGRESS_PATH = LISTING_INDEX_DIR / "progress.json"
+REPORT_PATH = LISTING_INDEX_DIR / "cleaning_report.json"
+BUILD_LOG_PATH = LISTING_INDEX_DIR / "build.log"
+SERVER_LOG_PATH = APP_ROOT / "logs" / "server.log"
+IMAGE_DIR = APP_ROOT / "images"
+BASE_MODEL_PATH = CLIP_DIR / "models" / "open_clip_pytorch_model.bin"
+TRAINED_CHECKPOINT_PATH = CLIP_DIR / "data" / "yunqi_clip_training" / "last_checkpoint.pt"
+HTML_PATH = APP_ROOT / "app" / "listing_search.html" if (APP_ROOT / "app" / "listing_search.html").exists() else APP_ROOT / "listing_search.html"
+BUILD_SCRIPT_PATH = APP_ROOT / "work" / "build_full_listing_index.py"
+MODEL_NAME = "ViT-B-32"
+CONFIG_PATH = APP_ROOT / "config.json"
+RUNTIME_METADATA_FIELDS = [
+    "id",
+    "title",
+    "listing_key",
+    "family_key",
+    "image_url",
+    "price_usd",
+    "sales_total",
+]
+KIMI_API_KEY_ENV = "MOONSHOT_API_KEY"
+KIMI_ENDPOINT_ENV = "KIMI_ENDPOINT"
+KIMI_MODEL_ENV = "KIMI_MODEL"
+APP_CONFIG = {}
+KIMI_CONFIG = {}
+KIMI_API_URL = "https://api.moonshot.cn/v1/chat/completions"
+KIMI_MODEL = "kimi-k2.6"
+KIMI_TEMPERATURE = 0.6
+KIMI_MAX_COMPLETION_TOKENS = 1200
+KIMI_PROMPT_BATCH_RANGES = [(1, 3), (4, 6), (7, 10)]
+KIMI_PROMPT_SLOT_RANGES = KIMI_PROMPT_BATCH_RANGES
+DEFAULT_KIMI_SYSTEM_PROMPT = """
+你是跨境电商组货商品检索词生成器。你只根据用户上传的图片生成可一起售卖/一起购买的商品检索词。
+
+任务：输出10个“具体可采购商品”，用于后续纯 listing CLIP 检索。
+
+生成原则：
+1. 不要只找外观相似品；优先覆盖互补品、同场景加购、替代升级、耗材补充、收纳展示、维护清洁、配套工具、礼盒套装里的其他商品。
+2. 每条必须是具体商品，不要写大类、策略、理由或营销词。不要输出“配件、用品、产品、套装、工具”这种过宽泛词，除非前面有清晰具体限定。
+3. 中文 zh 要像能直接给采购看的商品短名：主体品类 + 关键材质/结构/场景/人群/规格，尽量 6-18 个中文字符。
+4. 英文 en 要像英文 listing 标题检索词：6-14 个英文词，必须包含明确 product noun，并尽量包含 material / shape / color / scene / target user / size / function 中的2-4个要素。
+5. 如果图片主体不确定，根据最明显视觉元素推断；不要解释不确定性。
+6. 10条之间要有明显差异，避免同义改写刷数量。
+
+输出格式：只返回合法 JSON 对象，且只能包含 prompts 字段。
+prompts 是长度为10的数组，每个元素只能包含 zh 和 en 两个字段。
+""".strip()
+
+RUNTIME_CACHE = {
+    "model": None,
+    "tokenizer": None,
+    "device": None,
+    "index": None,
+    "products": None,
+    "prices": None,
+}
+BUILD_PROCESS = {"process": None}
+
+
+def write_bundle_log(message, payload=None):
+    """Write one compact bundle API log line for the Node diagnostics collector."""
+    entry = {"message": str(message or ""), "payload": payload or {}}
+    sys.stderr.write("[BUNDLE API] " + json.dumps(entry, ensure_ascii=True) + "\n")
+    sys.stderr.flush()
+
+
+def load_app_config():
+    """Load local app configuration without requiring secrets to be committed."""
+    if not CONFIG_PATH.exists():
+        return {}
+    return json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+
+
+def read_kimi_config():
+    """Return Kimi settings from environment variables, config.json, and safe defaults."""
+    config = APP_CONFIG.get("kimi", {}) if isinstance(APP_CONFIG, dict) else {}
+    return {
+        "api_key": os.environ.get(KIMI_API_KEY_ENV, "").strip() or str(config.get("api_key", "")).strip(),
+        "endpoint": os.environ.get(KIMI_ENDPOINT_ENV, "").strip() or str(config.get("endpoint", KIMI_API_URL)).strip(),
+        "model": os.environ.get(KIMI_MODEL_ENV, "").strip() or str(config.get("model", KIMI_MODEL)).strip(),
+        "temperature": float(config.get("temperature", KIMI_TEMPERATURE)),
+        "max_completion_tokens": int(config.get("max_completion_tokens", KIMI_MAX_COMPLETION_TOKENS)),
+    }
+
+
+def read_json_file(path, fallback):
+    """Read a JSON file when it exists, otherwise return the fallback value."""
+    if not path.exists():
+        return fallback
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def read_faiss_index_file(path):
+    """Read a FAISS index through Python bytes so Windows Unicode paths stay valid."""
+    index_bytes = np.frombuffer(path.read_bytes(), dtype="uint8")
+    return faiss.deserialize_index(index_bytes)
+
+
+def resolve_listing_metadata_path():
+    """Return the slim runtime metadata when bundled, otherwise use the original build metadata."""
+    if RUNTIME_METADATA_PATH.exists():
+        return RUNTIME_METADATA_PATH
+    return METADATA_PATH
+
+
+def normalize_product_metadata_rows(rows):
+    """Convert compact runtime metadata rows back into product dictionaries."""
+    if not rows:
+        return []
+    if isinstance(rows[0], dict):
+        return rows
+    products = []
+    for row in rows:
+        product = {}
+        values = row if isinstance(row, list) else []
+        for index, field_name in enumerate(RUNTIME_METADATA_FIELDS):
+            if index < len(values) and values[index] not in (None, ""):
+                product[field_name] = values[index]
+        products.append(product)
+    return products
+
+
+APP_CONFIG = load_app_config()
+KIMI_CONFIG = read_kimi_config()
+KIMI_API_URL = KIMI_CONFIG["endpoint"]
+KIMI_MODEL = KIMI_CONFIG["model"]
+KIMI_TEMPERATURE = KIMI_CONFIG["temperature"]
+KIMI_MAX_COMPLETION_TOKENS = KIMI_CONFIG["max_completion_tokens"]
+
+
+def append_server_log(message):
+    """Append one timestamped server log line without recording secrets."""
+    SERVER_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+    with SERVER_LOG_PATH.open("a", encoding="utf-8") as log_file:
+        log_file.write(f"{timestamp} {message}\n")
+
+
+def should_skip_access_log(path):
+    """Return whether a noisy internal endpoint should be hidden from server logs."""
+    return path in {"/api/index/status", "/api/server/log", "/api/cdn/image"}
+
+
+def validate_cdn_image_url(image_url):
+    """Validate that the proxied image URL is a plain HTTP(S) CDN URL."""
+    parsed_url = urllib.parse.urlparse(str(image_url or "").strip())
+    if parsed_url.scheme not in {"http", "https"}:
+        raise ValueError("CDN image URL must be http or https")
+    if not parsed_url.netloc:
+        raise ValueError("CDN image URL host is missing")
+    return parsed_url.geturl()
+
+
+def fetch_cdn_image_bytes(safe_url):
+    """Fetch one validated CDN image in a worker thread for the async proxy endpoint."""
+    request = urllib.request.Request(
+        safe_url,
+        headers={
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
+        },
+        method="GET",
+    )
+    with urllib.request.urlopen(request, timeout=30) as cdn_response:
+        image_bytes = cdn_response.read()
+        content_type = cdn_response.headers.get("Content-Type", "image/jpeg")
+        status_code = getattr(cdn_response, "status", 200)
+    return image_bytes, content_type, status_code
+
+
+def read_server_log_filtered(max_bytes):
+    """Read recent server logs while hiding noisy internal heartbeat entries."""
+    raw_log = read_tail(SERVER_LOG_PATH, max_bytes)
+    hidden_patterns = [
+        " /api/index/status ",
+        " /api/server/log ",
+        " /api/cdn/image ",
+    ]
+    visible_lines = []
+    for line in raw_log.splitlines():
+        if not line.startswith("20"):
+            continue
+        if any(pattern in line for pattern in hidden_patterns):
+            continue
+        visible_lines.append(line)
+    return "\n".join(visible_lines)
+
+
+def load_model_runtime():
+    """Load the trained CLIP text tower only once per server process."""
+    if RUNTIME_CACHE["model"] is not None:
+        return
+    if not BASE_MODEL_PATH.exists() or not TRAINED_CHECKPOINT_PATH.exists():
+        raise FileNotFoundError("Base model or trained checkpoint is missing")
+    write_bundle_log("CLIP load progress", {"stage": "model_base", "progress": 78, "message": "正在载入 CLIP 基础模型。", "status": "loading", "error": ""})
+    device = torch.device("cpu")
+    model, _, _ = open_clip.create_model_and_transforms(
+        MODEL_NAME,
+        pretrained=str(BASE_MODEL_PATH),
+    )
+    write_bundle_log("CLIP load progress", {"stage": "model_checkpoint", "progress": 87, "message": "正在载入 CLIP 训练权重。", "status": "loading", "error": ""})
+    checkpoint = torch.load(TRAINED_CHECKPOINT_PATH, map_location=device, weights_only=False)
+    model.load_state_dict(checkpoint["model"])
+    model = model.to(device)
+    model.eval()
+    RUNTIME_CACHE["model"] = model
+    RUNTIME_CACHE["tokenizer"] = open_clip.get_tokenizer(MODEL_NAME)
+    RUNTIME_CACHE["device"] = device
+    write_bundle_log("CLIP load progress", {"stage": "model_ready", "progress": 96, "message": "CLIP 模型已载入，正在完成初始化。", "status": "loading", "error": ""})
+
+
+def load_index_runtime():
+    """Load or reload the completed listing FAISS index and product metadata."""
+    metadata_path = resolve_listing_metadata_path()
+    if not INDEX_PATH.exists() or not metadata_path.exists():
+        raise FileNotFoundError("Listing index is not ready; start the build first")
+    progress = read_json_file(PROGRESS_PATH, {})
+    if progress.get("status") != "complete":
+        raise RuntimeError(
+            f"Listing index is still building: {progress.get('completed', 0)}/{progress.get('total', 0)}"
+        )
+    index_mtime = INDEX_PATH.stat().st_mtime
+    cached_mtime = RUNTIME_CACHE.get("index_mtime")
+    if RUNTIME_CACHE["index"] is not None and cached_mtime == index_mtime:
+        return
+    write_bundle_log("CLIP load progress", {"stage": "index", "progress": 46, "message": "正在载入 FAISS 商品索引。", "status": "loading", "error": ""})
+    RUNTIME_CACHE["index"] = read_faiss_index_file(INDEX_PATH)
+    write_bundle_log("CLIP load progress", {"stage": "metadata", "progress": 60, "message": "正在载入商品元数据。", "status": "loading", "error": ""})
+    RUNTIME_CACHE["products"] = normalize_product_metadata_rows(read_json_file(metadata_path, []))
+    write_bundle_log("CLIP load progress", {"stage": "prices", "progress": 70, "message": "正在载入价格数据。", "status": "loading", "error": ""})
+    RUNTIME_CACHE["prices"] = read_json_file(PRICE_METADATA_PATH, {})
+    RUNTIME_CACHE["index_mtime"] = index_mtime
+    if RUNTIME_CACHE["index"].ntotal != len(RUNTIME_CACHE["products"]):
+        raise RuntimeError("Listing index count does not match metadata count")
+
+
+def encode_text(query):
+    """Encode one listing query with the trained CLIP text tower."""
+    load_model_runtime()
+    tokenizer = RUNTIME_CACHE["tokenizer"]
+    model = RUNTIME_CACHE["model"]
+    device = RUNTIME_CACHE["device"]
+    tokens = tokenizer([query]).to(device)
+    with torch.inference_mode():
+        feature = model.encode_text(tokens)
+        feature = feature / feature.norm(dim=-1, keepdim=True)
+    return feature.cpu().numpy().astype("float32")
+
+
+def get_rank_window(top_k):
+    """Clamp the requested result count to a practical range."""
+    return max(1, min(int(top_k), 100))
+
+
+def should_keep_price(product, min_price, max_price):
+    """Return whether a product is inside the optional USD price range."""
+    if min_price is None and max_price is None:
+        return True
+    price = product.get("price_usd")
+    if price is None:
+        return False
+    if min_price is not None and float(price) < float(min_price):
+        return False
+    if max_price is not None and float(price) > float(max_price):
+        return False
+    return True
+
+
+def resolve_product_image_url(product):
+    """Return the MAINIMAGE/CDN URL from metadata, or an empty string when unavailable."""
+    image_fields = [
+        "MAINIMAGE",
+        "mainImage",
+        "main_image",
+        "mainimage",
+        "image_url",
+        "imgUrl",
+        "img_url",
+    ]
+    for field_name in image_fields:
+        image_value = str(product.get(field_name, "") or "").strip()
+        if image_value.lower().startswith(("http://", "https://")):
+            return image_value
+    return ""
+
+
+def add_sidecar_fields(product):
+    """Attach price data and the required CDN image URL to one product."""
+    product_id = str(product.get("id", ""))
+    prices = RUNTIME_CACHE["prices"] or {}
+    if product_id in prices:
+        product.update(prices[product_id])
+    product["img_url"] = resolve_product_image_url(product)
+    return product
+
+
+def search_listing_index(query_vector, top_k, min_price, max_price):
+    """Search the text index and dedupe similar listing families before returning."""
+    load_index_runtime()
+    index = RUNTIME_CACHE["index"]
+    products = RUNTIME_CACHE["products"]
+    output_count = get_rank_window(top_k)
+    if min_price is not None or max_price is not None:
+        search_count = index.ntotal
+    else:
+        search_count = min(index.ntotal, max(output_count * 30, 300))
+    scores, indices = index.search(query_vector, search_count)
+    results = []
+    seen_families = set()
+    seen_images = set()
+    result_position = 0
+    while result_position < len(indices[0]):
+        product_index = int(indices[0][result_position])
+        if product_index < 0 or product_index >= len(products):
+            result_position += 1
+            continue
+        product = products[product_index].copy()
+        product = add_sidecar_fields(product)
+        if not product.get("img_url"):
+            result_position += 1
+            continue
+        if not should_keep_price(product, min_price, max_price):
+            result_position += 1
+            continue
+        family_key = str(product.get("family_key", product.get("listing_key", "")))
+        image_key = str(product.get("local_img", product.get("image_url", "")))
+        if family_key in seen_families or image_key in seen_images:
+            result_position += 1
+            continue
+        product["similarity"] = round(float(scores[0][result_position]) * 100, 2)
+        product["rank"] = len(results) + 1
+        product["source"] = "Listing"
+        results.append(product)
+        seen_families.add(family_key)
+        seen_images.add(image_key)
+        if len(results) >= output_count:
+            break
+        result_position += 1
+    return results
+
+
+def image_to_data_url(image):
+    """Encode an uploaded image as a compact Kimi-compatible data URL."""
+    image_copy = image.copy().convert("RGB")
+    image_copy.thumbnail((1280, 1280))
+    image_buffer = io.BytesIO()
+    image_copy.save(image_buffer, format="JPEG", quality=85, optimize=True)
+    encoded = base64.b64encode(image_buffer.getvalue()).decode("ascii")
+    return f"data:image/jpeg;base64,{encoded}"
+
+
+def read_uploaded_image(contents):
+    """Read uploaded bytes into a normalized PIL image."""
+    if not contents:
+        return None
+    return Image.open(io.BytesIO(contents)).convert("RGB")
+
+
+def parse_kimi_prompt_json(response_data):
+    """Extract the JSON prompt object from one Kimi chat completion response."""
+    choices = response_data.get("choices", []) if isinstance(response_data, dict) else []
+    if not choices:
+        raise RuntimeError("Kimi API returned no choices")
+    content_text = choices[0].get("message", {}).get("content", "")
+    if isinstance(content_text, dict):
+        return content_text
+    try:
+        return json.loads(content_text)
+    except (TypeError, json.JSONDecodeError) as error:
+        raise RuntimeError("Kimi response is not valid JSON") from error
+
+
+def collect_kimi_batch_prompts(raw_plan):
+    """Return valid prompts in the exact order supplied by one completed Kimi batch."""
+    raw_prompts = raw_plan.get("prompts", []) if isinstance(raw_plan, dict) else []
+    if not isinstance(raw_prompts, list):
+        return []
+    prompts = []
+    skipped_count = 0
+    for idx, raw_prompt in enumerate(raw_prompts):
+        if isinstance(raw_prompt, dict):
+            prompt_item = {
+                "zh": str(raw_prompt.get("zh", raw_prompt.get("prompt", ""))).strip(),
+                "en": str(raw_prompt.get("en", raw_prompt.get("prompt_en", ""))).strip(),
+            }
+        else:
+            prompt_item = {"zh": str(raw_prompt).strip(), "en": ""}
+        if prompt_item["zh"] or prompt_item["en"]:
+            prompts.append(prompt_item)
+        else:
+            skipped_count += 1
+            write_bundle_log("Kimi prompt skipped (empty)", {
+                "index": idx,
+                "raw": raw_prompt,
+            })
+    if skipped_count > 0:
+        write_bundle_log("Kimi batch prompts collected", {
+            "valid": len(prompts),
+            "skipped": skipped_count,
+            "total": len(raw_prompts),
+        })
+    return prompts
+
+
+def call_kimi_prompt_batch(image_data_url, min_price, max_price, kimi_prompt, batch_start, batch_end, kimi_user_prompt=""):
+    """Ask Kimi for one independent batch whose results keep provider return order."""
+    api_key = KIMI_CONFIG["api_key"]
+    if not api_key:
+        raise RuntimeError(f"Missing Kimi api_key in {CONFIG_PATH.name} or {KIMI_API_KEY_ENV} environment variable")
+    price_rule = {"currency": "USD", "min": min_price, "max": max_price}
+    batch_count = max(1, batch_end - batch_start + 1)
+    system_prompt = (kimi_prompt or DEFAULT_KIMI_SYSTEM_PROMPT).strip()
+    user_prompt = str(kimi_user_prompt or "").strip()
+    schema_guard = (
+        "\n\n硬性输出约束：只返回合法JSON对象，不能返回Markdown代码围栏。"
+        f"JSON只能包含prompts字段；prompts必须是长度为{batch_count}的数组；"
+        "每个元素只能包含zh和en两个字段，不要输出slot。"
+    )
+    user_text = (
+        (user_prompt + "\n\n" if user_prompt else "")
+        + f"请生成本批次的 {batch_count} 个 CLIP 检索方向。"
+        "这些结果会按照各批次实际返回先后拼接，不要输出编号。\n"
+        "Price filter:\n"
+        + json.dumps(price_rule, ensure_ascii=False)
+        + "\n只返回JSON，不要Markdown代码围栏。"
+    )
+    content = [{"type": "text", "text": user_text}]
+    if image_data_url:
+        content.insert(0, {"type": "image_url", "image_url": {"url": image_data_url}})
+    payload = {
+        "model": KIMI_MODEL,
+        "messages": [
+            {"role": "system", "content": system_prompt + schema_guard},
+            {"role": "user", "content": content},
+        ],
+        "thinking": {"type": "disabled"},
+        "temperature": KIMI_TEMPERATURE,
+        "response_format": {"type": "json_object"},
+        "max_completion_tokens": min(KIMI_MAX_COMPLETION_TOKENS, 650),
+    }
+    request = urllib.request.Request(
+        KIMI_API_URL,
+        data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
+        headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+        method="POST",
+    )
+    response_data = None
+    attempt = 0
+    while attempt < 3:
+        try:
+            write_bundle_log("Kimi prompts POST", {
+                "endpoint": KIMI_API_URL,
+                "model": KIMI_MODEL,
+                "attempt": attempt + 1,
+                "batch_start": batch_start,
+                "batch_end": batch_end,
+                "min_price": min_price,
+                "max_price": max_price,
+            })
+            with urllib.request.urlopen(request, timeout=120) as response:
+                response_data = json.loads(response.read().decode("utf-8"))
+            write_bundle_log("Kimi prompts response", {
+                "status": "ok",
+                "model": KIMI_MODEL,
+                "attempt": attempt + 1,
+                "batch_start": batch_start,
+                "batch_end": batch_end,
+            })
+            break
+        except urllib.error.HTTPError as error:
+            detail = error.read().decode("utf-8", errors="replace")
+            write_bundle_log("Kimi prompts HTTP error", {
+                "status": error.code,
+                "attempt": attempt + 1,
+                "batch_start": batch_start,
+                "batch_end": batch_end,
+                "detail": detail[:300],
+            })
+            if error.code not in (429, 500, 502, 503, 504) or attempt >= 2:
+                raise RuntimeError(f"Kimi API HTTP {error.code}: {detail[:500]}") from error
+            retry_after = error.headers.get("Retry-After")
+            try:
+                delay = float(retry_after) if retry_after else 2.0 + attempt * 2.0
+            except (TypeError, ValueError):
+                delay = 2.0 + attempt * 2.0
+            time.sleep(min(max(delay, 1.0), 10.0))
+            attempt += 1
+        except urllib.error.URLError as error:
+            write_bundle_log("Kimi prompts network error", {
+                "attempt": attempt + 1,
+                "batch_start": batch_start,
+                "batch_end": batch_end,
+                "reason": str(error.reason),
+            })
+            if attempt >= 2:
+                raise RuntimeError(f"Kimi API network error: {error.reason}") from error
+            time.sleep(2.0 + attempt * 2.0)
+            attempt += 1
+    raw_plan = parse_kimi_prompt_json(response_data)
+    prompts = collect_kimi_batch_prompts(raw_plan)
+    write_bundle_log("Kimi batch complete", {
+        "batch_start": batch_start,
+        "batch_end": batch_end,
+        "expected_count": batch_end - batch_start + 1,
+        "actual_count": len(prompts),
+        "raw_response": response_data,
+    })
+    return prompts
+
+
+def call_kimi_prompts(image, min_price, max_price, kimi_prompt, max_workers=3, on_batch_completed=None, kimi_user_prompt=""):
+    """Ask Kimi concurrently for ten JSON bundle-product prompts, ordered by completion time."""
+    image_data_url = image_to_data_url(image) if image is not None else ""
+    batch_ranges = KIMI_PROMPT_BATCH_RANGES
+    safe_workers = max(1, min(int(max_workers or 1), len(batch_ranges)))
+    completed_prompts = []
+    errors = []
+    with concurrent.futures.ThreadPoolExecutor(max_workers=safe_workers) as executor:
+        future_map = {}
+        for batch_start, batch_end in batch_ranges:
+            future = executor.submit(
+                call_kimi_prompt_batch,
+                image_data_url,
+                min_price,
+                max_price,
+                kimi_prompt,
+                batch_start,
+                batch_end,
+                kimi_user_prompt,
+            )
+            future_map[future] = (batch_start, batch_end)
+        for future in concurrent.futures.as_completed(future_map):
+            batch_start, batch_end = future_map[future]
+            try:
+                batch_prompts = future.result()
+                completed_prompts.extend(batch_prompts)
+                if callable(on_batch_completed) and batch_prompts:
+                    on_batch_completed(batch_start, batch_end, batch_prompts)
+            except Exception as error:
+                errors.append(f"{batch_start}-{batch_end}: {error}")
+                write_bundle_log("Kimi prompt batch failed", {
+                    "batch_start": batch_start,
+                    "batch_end": batch_end,
+                    "error": str(error),
+                })
+    if not completed_prompts and errors:
+        raise RuntimeError("Kimi parallel prompts failed: " + "; ".join(errors))
+    write_bundle_log("Kimi all batches complete", {
+        "total_prompts": len(completed_prompts),
+        "expected_total": sum(end - start + 1 for start, end in batch_ranges),
+        "batch_count": len(batch_ranges),
+        "errors": errors,
+    })
+    return {"prompts": completed_prompts, "batch_errors": errors, "batch_workers": safe_workers}
+
+
+def normalize_kimi_prompts(raw_plan, fill_missing=True):
+    """Validate Kimi prompts and optionally fill missing directions."""
+    raw_prompts = raw_plan.get("prompts", []) if isinstance(raw_plan, dict) else []
+    if not isinstance(raw_prompts, list):
+        raw_prompts = []
+    prompts = []
+    for raw_prompt in raw_prompts:
+        if isinstance(raw_prompt, dict):
+            prompt_zh = str(raw_prompt.get("zh", raw_prompt.get("prompt", ""))).strip()
+            prompt_en = str(raw_prompt.get("en", raw_prompt.get("prompt_en", ""))).strip()
+        else:
+            prompt_zh = str(raw_prompt).strip()
+            prompt_en = ""
+        if not prompt_zh and not prompt_en:
+            continue
+        prompts.append({"zh": prompt_zh, "en": prompt_en})
+        if len(prompts) >= 10:
+            break
+    fallback_text = "related product bundle"
+    if fill_missing:
+        while len(prompts) < 10:
+            prompts.append({"zh": fallback_text, "en": fallback_text})
+    return {"prompts": prompts}
+
+
+def search_prompt_groups(prompts, min_price, max_price, top_k, prompt_offset=0):
+    """Run each Kimi prompt through the listing CLIP index and group results."""
+    groups = []
+    selected_results = []
+    prompt_index = 0
+    while prompt_index < len(prompts):
+        prompt_item = prompts[prompt_index]
+        recall_text = prompt_item.get("en") or prompt_item.get("zh") or ""
+        query_vector = encode_text(recall_text)
+        matches = search_listing_index(query_vector, top_k, min_price, max_price)
+        group_results = []
+        result_index = 0
+        while result_index < len(matches):
+            product = matches[result_index].copy()
+            product["prompt_index"] = prompt_offset + prompt_index + 1
+            product["search_prompt"] = prompt_item.get("zh", "")
+            product["search_prompt_en"] = prompt_item.get("en", "")
+            product["prompt_rank"] = result_index + 1
+            group_results.append(product)
+            selected_results.append(product)
+            result_index += 1
+        groups.append(
+            {
+                "prompt_index": prompt_offset + prompt_index + 1,
+                "prompt": prompt_item.get("zh", ""),
+                "prompt_en": prompt_item.get("en", ""),
+                "results": group_results,
+            }
+        )
+        prompt_index += 1
+    return groups, selected_results
+
+
+def read_tail(path, max_bytes):
+    """Read the end of a log file without loading the whole file."""
+    if not path.exists():
+        return ""
+    with path.open("rb") as log_file:
+        log_file.seek(0, os.SEEK_END)
+        size = log_file.tell()
+        log_file.seek(max(0, size - max_bytes), os.SEEK_SET)
+        return log_file.read().decode("utf-8", errors="replace")
+
+
+def is_build_running():
+    """Return whether the current build subprocess is still active."""
+    process = BUILD_PROCESS.get("process")
+    if process is None:
+        return False
+    return process.poll() is None
+
+
+def start_build_process(batch_size, force_clean):
+    """Start the listing-index build in the background and append logs."""
+    if is_build_running():
+        return False
+    LISTING_INDEX_DIR.mkdir(parents=True, exist_ok=True)
+    command = [
+        sys.executable,
+        str(BUILD_SCRIPT_PATH),
+        "--batch-size",
+        str(max(1, min(int(batch_size), 2048))),
+    ]
+    if force_clean:
+        command.append("--force-clean")
+    log_file = BUILD_LOG_PATH.open("a", encoding="utf-8")
+    log_file.write(f"\nserver_start_build {command}\n")
+    log_file.flush()
+    BUILD_PROCESS["process"] = subprocess.Popen(
+        command,
+        stdout=log_file,
+        stderr=subprocess.STDOUT,
+        cwd=str(BUILD_SCRIPT_PATH.parent),
+    )
+    return True
+
+
+def build_status_payload():
+    """Return progress, cleaning report, and recent build log for the UI."""
+    progress = read_json_file(PROGRESS_PATH, {})
+    report = read_json_file(REPORT_PATH, {})
+    inferred_running = is_build_running()
+    if not inferred_running and progress.get("status") == "building":
+        completed = int(progress.get("completed", 0) or 0)
+        total = int(progress.get("total", 0) or 0)
+        inferred_running = total > 0 and completed < total
+    payload = {
+        "running": inferred_running,
+        "progress": progress,
+        "report": report,
+        "log": read_tail(BUILD_LOG_PATH, 20000),
+        "index_exists": INDEX_PATH.exists(),
+        "metadata_exists": resolve_listing_metadata_path().exists(),
+    }
+    if INDEX_PATH.exists():
+        payload["index_size_mb"] = round(INDEX_PATH.stat().st_size / 1024 / 1024, 2)
+    return payload
+
+
+def create_app():
+    """Create the legacy FastAPI application for pure listing search."""
+    application = FastAPI(title="Pure Listing CLIP Search")
+    application.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    if IMAGE_DIR.exists():
+        application.mount("/listing-images", StaticFiles(directory=IMAGE_DIR), name="listing-images")
+
+    @application.middleware("http")
+    async def log_http_request(request: Request, call_next):
+        """Write one compact access log line for every API/page request."""
+        started_at = time.perf_counter()
+        skip_access_log = should_skip_access_log(request.url.path)
+        try:
+            response = await call_next(request)
+        except Exception as error:
+            duration_ms = int((time.perf_counter() - started_at) * 1000)
+            if not skip_access_log:
+                append_server_log(
+                    f"{request.method} {request.url.path} ERROR {duration_ms}ms {type(error).__name__}: {error}"
+                )
+            raise
+        duration_ms = int((time.perf_counter() - started_at) * 1000)
+        if not skip_access_log:
+            append_server_log(
+                f"{request.method} {request.url.path} {response.status_code} {duration_ms}ms"
+            )
+        return response
+
+    @application.get("/api/server/log", response_class=PlainTextResponse)
+    async def server_log(max_bytes: int = 50000):
+        """Return the recent local server log as plain text."""
+        safe_max_bytes = max(1000, min(int(max_bytes), 1000000))
+        return PlainTextResponse(read_server_log_filtered(safe_max_bytes))
+
+    @application.get("/api/cdn/image")
+    async def proxy_cdn_image(url: str):
+        """Fetch one remote CDN image through this server so the request is visible in logs."""
+        started_at = time.perf_counter()
+        try:
+            safe_url = validate_cdn_image_url(url)
+            image_bytes, content_type, status_code = await asyncio.to_thread(fetch_cdn_image_bytes, safe_url)
+            duration_ms = int((time.perf_counter() - started_at) * 1000)
+            append_server_log(f"CDN GET {safe_url} {status_code} {len(image_bytes)}B {duration_ms}ms")
+            return Response(
+                content=image_bytes,
+                media_type=content_type,
+                headers={"Cache-Control": "public, max-age=86400"},
+            )
+        except Exception as error:
+            duration_ms = int((time.perf_counter() - started_at) * 1000)
+            append_server_log(f"CDN GET {url} ERROR {duration_ms}ms {type(error).__name__}: {error}")
+            return Response(status_code=502)
+
+    @application.post("/api/index/build/start")
+    async def start_index_build(
+        batch_size: int = Form(256),
+        force_clean: bool = Form(False),
+    ):
+        """Start a background cleaned listing-index build."""
+        try:
+            started = start_build_process(batch_size, force_clean)
+            return {"started": started, "status": build_status_payload()}
+        except Exception as error:
+            return JSONResponse({"error": str(error)}, status_code=400)
+
+    @application.get("/api/index/status")
+    async def index_status():
+        """Return listing-index build and load status."""
+        status = build_status_payload()
+        status["kimi_model"] = KIMI_MODEL
+        status["kimi_configured"] = bool(KIMI_CONFIG["api_key"])
+        if INDEX_PATH.exists() and METADATA_PATH.exists():
+            try:
+                load_index_runtime()
+                status["vectors"] = RUNTIME_CACHE["index"].ntotal
+                status["products"] = len(RUNTIME_CACHE["products"])
+                status["price_records"] = len(RUNTIME_CACHE["prices"])
+            except Exception as error:
+                status["load_error"] = str(error)
+        return status
+
+    @application.post("/api/search/text")
+    async def search_text(
+        query: str = Form(...),
+        top_k: int = Form(24),
+        min_price: float = Form(None),
+        max_price: float = Form(None),
+    ):
+        """Search the cleaned pure-listing index."""
+        try:
+            if not query.strip():
+                raise ValueError("Query is empty")
+            query_vector = encode_text(query.strip())
+            results = search_listing_index(query_vector, top_k, min_price, max_price)
+            return {"results": results}
+        except Exception as error:
+            return JSONResponse({"error": str(error)}, status_code=400)
+
+    @application.post("/api/search/prompts")
+    async def search_prompts(payload: dict = Body(...)):
+        """Search the listing index with manually edited Kimi prompt JSON."""
+        try:
+            plan = normalize_kimi_prompts(payload, fill_missing=False)
+            if not plan["prompts"]:
+                raise ValueError("Edited prompts are empty")
+            min_price = payload.get("min_price")
+            max_price = payload.get("max_price")
+            safe_top_k = max(1, min(int(payload.get("top_k", 1)), 10))
+            groups, selected_results = search_prompt_groups(
+                plan["prompts"],
+                min_price,
+                max_price,
+                safe_top_k,
+            )
+            return {
+                "plan": plan,
+                "groups": groups,
+                "results": selected_results,
+                "prompts_searched": len(groups),
+                "results_per_prompt": safe_top_k,
+                "source": "edited_prompts",
+            }
+        except Exception as error:
+            return JSONResponse({"error": str(error)}, status_code=400)
+
+    @application.post("/api/assemble")
+    async def assemble_products(
+        file: UploadFile = File(None),
+        listing: str = Form(""),
+        kimi_prompt: str = Form(""),
+        top_k: int = Form(2),
+        min_price: float = Form(None),
+        max_price: float = Form(None),
+    ):
+        """Run image-only Kimi JSON prompts, then search the listing CLIP index.
+        核心流程（按你要求）：
+        - Kimi 生成 10 个方向（3+3+4 并发）
+        - 哪个 Kimi 批次先返回，哪个批次先进入 CLIP
+        - 当前接口保持一次性返回，不使用 SSE
+        - 最终固定返回 10 个商品，按 Kimi 实际返回顺序排序
+        """
+        try:
+            contents = await file.read() if file and file.filename else None
+            image = read_uploaded_image(contents)
+            if image is None:
+                raise ValueError("Please upload an image for Kimi bundle generation")
+            effective_system_prompt = DEFAULT_KIMI_SYSTEM_PROMPT
+            effective_user_prompt = kimi_prompt.strip()
+            safe_top_k = max(1, min(int(top_k), 10))
+            batch_groups = []
+            selected_results = []
+            searched_prompt_count = 0
+
+            def search_completed_kimi_batch(_batch_start, _batch_end, batch_prompts):
+                """Search one completed Kimi batch before slower Kimi batches finish."""
+                nonlocal searched_prompt_count
+                batch_plan = normalize_kimi_prompts({"prompts": batch_prompts}, fill_missing=False)
+                prompts = batch_plan["prompts"]
+                if not prompts:
+                    return
+                groups, batch_results = search_prompt_groups(
+                    prompts,
+                    min_price,
+                    max_price,
+                    safe_top_k,
+                    searched_prompt_count,
+                )
+                searched_prompt_count += len(prompts)
+                batch_groups.extend(groups)
+                selected_results.extend(batch_results)
+
+            # === Kimi 批次返回后立即进入 CLIP，接口最终一次返回 ===
+            raw_plan = call_kimi_prompts(
+                image,
+                min_price,
+                max_price,
+                effective_system_prompt,
+                on_batch_completed=search_completed_kimi_batch,
+                kimi_user_prompt=effective_user_prompt,
+            )
+            plan = normalize_kimi_prompts(raw_plan)
+            groups = batch_groups
+            if not groups:
+                groups, selected_results = search_prompt_groups(plan["prompts"], min_price, max_price, safe_top_k)
+
+            # === 固定返回 10 个商品 ===
+            if len(selected_results) > 10:
+                selected_results = selected_results[:10]
+            elif len(selected_results) < 10:
+                while len(selected_results) < 10:
+                    selected_results.append({
+                        "id": f"fallback-{len(selected_results)}",
+                        "title": "related product bundle",
+                        "prompt_index": 1,
+                        "search_prompt": "",
+                        "search_prompt_en": "",
+                        "prompt_rank": 1,
+                        "similarity": 50.0,
+                        "source": "fallback"
+                    })
+
+            return {
+                "plan": plan,
+                "groups": groups,
+                "results": selected_results,
+                "prompts_searched": len(groups),
+                "results_per_prompt": safe_top_k,
+                "model": KIMI_MODEL,
+                "thinking": "disabled",
+                "kimi_prompt": effective_user_prompt,
+                "return_count": len(selected_results)
+            }
+        except Exception as error:
+            return JSONResponse({"error": str(error)}, status_code=400)
+
+    @application.get("/", response_class=HTMLResponse)
+    async def listing_page():
+        """Serve the standalone pure-listing search page."""
+        return HTMLResponse(HTML_PATH.read_text(encoding="utf-8"))
+
+    return application
+
+
+app = create_app()
+
+
+if __name__ == "__main__":
+    raise SystemExit("9990 HTTP service is disabled. Use stdio_listing_worker.py through the 3000 server.")

work/stdio_listing_worker.py

@@ -0,0 +1,184 @@
+"""Serve CLIP listing operations over stdin/stdout without opening an HTTP port."""
+
+import base64
+import json
+import sys
+
+from full_listing_server import (
+    call_kimi_prompts,
+    read_uploaded_image,
+    normalize_kimi_prompts,
+    search_prompt_groups,
+    encode_text,
+    search_listing_index,
+    build_status_payload,
+    load_index_runtime,
+    load_model_runtime,
+    RUNTIME_CACHE,
+    KIMI_CONFIG,
+    KIMI_MODEL,
+    DEFAULT_KIMI_SYSTEM_PROMPT,
+)
+
+
+def configure_stdio_encoding():
+    """Force safe UTF-8 stream writes even when data contains surrogate escapes."""
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure:
+            reconfigure(encoding="utf-8", errors="backslashreplace")
+
+
+def write_json_line(payload):
+    """Write one JSON response line and flush immediately for the Node parent."""
+    sys.stdout.write(json.dumps(payload, ensure_ascii=True) + "\n")
+    sys.stdout.flush()
+
+
+def read_optional_float(value):
+    """Convert one optional numeric value from JSON into a float or None."""
+    if value is None or value == "":
+        return None
+    return float(value)
+
+
+def read_uploaded_image_from_base64(value):
+    """Decode one base64 image payload into a normalized PIL image."""
+    if not value:
+        return None
+    return read_uploaded_image(base64.b64decode(str(value)))
+
+
+def handle_index_status(_payload):
+    """Return listing-index readiness without requiring an HTTP request."""
+    status = build_status_payload()
+    status["kimi_model"] = KIMI_MODEL
+    status["kimi_configured"] = bool(KIMI_CONFIG["api_key"])
+    try:
+        load_index_runtime()
+        status["vectors"] = RUNTIME_CACHE["index"].ntotal
+        status["products"] = len(RUNTIME_CACHE["products"])
+        status["price_records"] = len(RUNTIME_CACHE["prices"])
+    except Exception as error:
+        status["load_error"] = str(error)
+    return status
+
+
+def handle_warmup(_payload):
+    """Load the listing index and trained text model before the first search."""
+    load_index_runtime()
+    load_model_runtime()
+    return {
+        "vectors": RUNTIME_CACHE["index"].ntotal,
+        "products": len(RUNTIME_CACHE["products"]),
+        "model_ready": RUNTIME_CACHE["model"] is not None,
+    }
+
+
+def handle_search_text(payload):
+    """Search the listing CLIP index with one manual keyword."""
+    query = str(payload.get("query", "")).strip()
+    if not query:
+        raise ValueError("Query is empty")
+    top_k = max(1, min(int(payload.get("top_k", 24)), 100))
+    min_price = read_optional_float(payload.get("min_price"))
+    max_price = read_optional_float(payload.get("max_price"))
+    query_vector = encode_text(query)
+    return {"results": search_listing_index(query_vector, top_k, min_price, max_price)}
+
+
+def handle_assemble(payload):
+    """Run image-only Kimi JSON prompts, then search the listing CLIP index."""
+    image = read_uploaded_image_from_base64(payload.get("image_base64"))
+    if image is None:
+        raise ValueError("Please provide an image for Kimi bundle generation")
+    min_price = read_optional_float(payload.get("min_price"))
+    max_price = read_optional_float(payload.get("max_price"))
+    effective_system_prompt = str(payload.get("kimi_system_prompt", "")).strip() or DEFAULT_KIMI_SYSTEM_PROMPT
+    effective_user_prompt = str(payload.get("kimi_prompt", "")).strip()
+    safe_top_k = max(1, min(int(payload.get("top_k", 2)), 10))
+    batch_groups = []
+    batch_selected_results = []
+    searched_prompt_count = 0
+
+    def search_completed_kimi_batch(_batch_start, _batch_end, batch_prompts):
+        """Search one returned Kimi batch immediately so later Kimi calls do not block CLIP."""
+        nonlocal searched_prompt_count
+        batch_plan = normalize_kimi_prompts({"prompts": batch_prompts}, fill_missing=False)
+        prompts = batch_plan["prompts"]
+        if not prompts:
+            return
+        groups, selected_results = search_prompt_groups(
+            prompts,
+            min_price,
+            max_price,
+            safe_top_k,
+            searched_prompt_count,
+        )
+        searched_prompt_count += len(prompts)
+        batch_groups.extend(groups)
+        batch_selected_results.extend(selected_results)
+
+    raw_plan = call_kimi_prompts(
+        image,
+        min_price,
+        max_price,
+        effective_system_prompt,
+        on_batch_completed=search_completed_kimi_batch,
+        kimi_user_prompt=effective_user_prompt,
+    )
+    plan = normalize_kimi_prompts(raw_plan)
+    if batch_groups:
+        groups = batch_groups
+        selected_results = batch_selected_results
+    else:
+        groups, selected_results = search_prompt_groups(plan["prompts"], min_price, max_price, safe_top_k)
+    return {
+        "plan": plan,
+        "groups": groups,
+        "results": selected_results,
+        "prompts_searched": len(groups),
+        "results_per_prompt": safe_top_k,
+        "model": KIMI_MODEL,
+        "thinking": "disabled",
+        "kimi_prompt": effective_user_prompt,
+    }
+
+
+def dispatch(payload):
+    """Route one worker JSON command to the matching CLIP operation."""
+    action = str(payload.get("action", "")).strip()
+    if action == "index_status":
+        return handle_index_status(payload)
+    if action == "warmup":
+        return handle_warmup(payload)
+    if action == "search_text":
+        return handle_search_text(payload)
+    if action == "assemble":
+        return handle_assemble(payload)
+    raise ValueError("Unknown CLIP worker action: " + action)
+
+
+def main():
+    """Read JSON-line requests forever and return JSON-line responses."""
+    for line in sys.stdin:
+        text = line.strip()
+        if not text:
+            continue
+        request = {}
+        try:
+            request = json.loads(text)
+            request_id = request.get("id")
+            result = dispatch(request)
+            write_json_line({"id": request_id, "ok": True, "result": result})
+        except Exception as error:
+            write_json_line({
+                "id": request.get("id", ""),
+                "ok": False,
+                "error": str(error),
+            })
+
+
+if __name__ == "__main__":
+    configure_stdio_encoding()
+    main()