tangwang · tangwang · tangwang · tangwang · tangwang
Showing 39 changed files Show diff stats
config/__init__.py
config/config.yaml
config/env_config.py
config/loader.py
config/schema.py
config/services_config.py
context/request_context.py
docs/TODO-ES能力提升.md -> docs/issue-2026-03-21-ES能力提升.md
docs/TODO-意图判断-done.md -> docs/issue-2026-03-21-意图判断-done03-24.md
docs/issue-2026-03-26-ES文本搜索-补充多模态knn放入should-done-0327.md
docs/issue-2026-03-27-keywords限定-done-0327.txt
docs/issue-2026-03-27-添加粗排精排-第2轮-done-0327.txt
docs/issue-2026-03-27-添加粗排精排-第一轮-done-0327.txt
docs/TODO.md -> docs/issue.md
docs/TODO.txt -> docs/issue.txt
docs/常用查询 - sql.sql
frontend/static/css/style.css
frontend/static/js/app.js
providers/rerank.py
query/__init__.py
@@ -4,6 +4,9 @@ from config.config_loader import ConfigLoader, ConfigurationError
 from config.loader import AppConfigLoader, get_app_config, reload_app_config
 from config.schema import (
     AppConfig,
+    CoarseRankConfig,
+    CoarseRankFusionConfig,
+    FineRankConfig,
     FunctionScoreConfig,
     IndexConfig,
     QueryConfig,
@@ -31,8 +34,11 @@ from config.utils import get_domain_fields, get_match_fields_for_index
 __all__ = [
     "AppConfig",
     "AppConfigLoader",
+    "CoarseRankConfig",
+    "CoarseRankFusionConfig",
     "ConfigLoader",
     "ConfigurationError",
+    "FineRankConfig",
     "FunctionScoreConfig",
     "IndexConfig",
     "QueryConfig",
@@ -100,16 +100,19 @@ query_config:
   # 查询翻译模型（须与 services.translation.capabilities 中某项一致）
   # 源语种在租户 index_languages 内：主召回可打在源语种字段，用下面三项。
-  # zh_to_en_model: "opus-mt-zh-en"
-  # en_to_zh_model: "opus-mt-en-zh"
-  # default_translation_model: "nllb-200-distilled-600m"
-  zh_to_en_model: "deepl"
-  en_to_zh_model: "deepl"
-  default_translation_model: "deepl"
+  zh_to_en_model: "nllb-200-distilled-600m" #  "opus-mt-zh-en"
+  en_to_zh_model: "nllb-200-distilled-600m" #  "opus-mt-en-zh"
+  default_translation_model: "nllb-200-distilled-600m"
+  # zh_to_en_model: "deepl"
+  # en_to_zh_model: "deepl"
+  # default_translation_model: "deepl"
   # 源语种不在 index_languages：翻译对可检索文本更关键，可单独指定（缺省则与上一组相同）
-  zh_to_en_model__source_not_in_index: "deepl"
-  en_to_zh_model__source_not_in_index: "deepl"
-  default_translation_model__source_not_in_index: "deepl"
+  zh_to_en_model__source_not_in_index: "nllb-200-distilled-600m"
+  en_to_zh_model__source_not_in_index: "nllb-200-distilled-600m"
+  default_translation_model__source_not_in_index: "nllb-200-distilled-600m"
+  # zh_to_en_model__source_not_in_index: "deepl"
+  # en_to_zh_model__source_not_in_index: "deepl"
+  # default_translation_model__source_not_in_index: "deepl"
   # 查询解析阶段：翻译与 query 向量并发执行，共用同一等待预算（毫秒）。
   # 检测语言已在租户 index_languages 内：较短；不在索引语言内：较长（翻译对召回更关键）。
@@ -153,8 +156,8 @@ query_config:
   # 统一文本召回策略（主查询 + 翻译查询）
   text_query_strategy:
-    base_minimum_should_match: "75%"
-    translation_minimum_should_match: "75%"
+    base_minimum_should_match: "60%"
+    translation_minimum_should_match: "60%"
     translation_boost: 0.75
     tie_breaker_base_query: 0.5
     best_fields_boost: 2.0
@@ -206,8 +209,18 @@ query_config:
     - specifications
     - skus
-  # KNN boost配置（向量召回的boost值）
-  knn_boost: 2.0  # Lower boost for embedding recall
+  # KNN：文本向量与多模态（图片）向量各自 boost 与召回（k / num_candidates）
+  knn_text_boost: 4
+  knn_image_boost: 4
+
+  knn_text_k: 150
+  knn_text_num_candidates: 400
+
+  knn_text_k_long: 300
+  knn_text_num_candidates_long: 720
+
+  knn_image_k: 300
+  knn_image_num_candidates: 720
 # Function Score配置（ES层打分规则）
 function_score:
@@ -215,15 +228,40 @@ function_score:
   boost_mode: "multiply"
   functions: []
+# 粗排配置（仅融合 ES 文本/向量信号，不调用模型）
+coarse_rank:
+  enabled: true
+  input_window: 700
+  output_window: 240
+  fusion:
+    text_bias: 0.1
+    text_exponent: 0.35
+    knn_text_weight: 1.0
+    knn_image_weight: 1.0
+    knn_tie_breaker: 0.1
+    knn_bias: 0.6
+    knn_exponent: 0.0
+
+# 精排配置（轻量 reranker）
+fine_rank:
+  enabled: true
+  input_window: 240
+  output_window: 80
+  timeout_sec: 10.0
+  rerank_query_template: "{query}"
+  rerank_doc_template: "{title}"
+  service_profile: "fine"
+
 # 重排配置（provider/URL 在 services.rerank）
 rerank:
   enabled: true
-  rerank_window: 400
+  rerank_window: 80
   timeout_sec: 15.0
   weight_es: 0.4
   weight_ai: 0.6
   rerank_query_template: "{query}"
   rerank_doc_template: "{title}"
+  service_profile: "default"
   # 乘法融合：fused = Π (max(score,0) + bias) ** exponent（rerank / text / knn 三项）
   # 其中 knn_score 先做一层 dis_max：
   #   max(knn_text_weight * text_knn, knn_image_weight * image_knn)
@@ -231,13 +269,15 @@ rerank:
   fusion:
     rerank_bias: 0.00001
     rerank_exponent: 1.0
+    fine_bias: 0.00001
+    fine_exponent: 1.0
     text_bias: 0.1
     text_exponent: 0.35
     knn_text_weight: 1.0
     knn_image_weight: 1.0
     knn_tie_breaker: 0.1
     knn_bias: 0.6
-    knn_exponent: 0.2
+    knn_exponent: 0.0
 # 可扩展服务/provider 注册表（单一配置源）
 services:
@@ -381,16 +421,31 @@ services:
         normalize_embeddings: true
   rerank:
     provider: "http"
-    base_url: "http://127.0.0.1:6007"
     providers:
       http:
-        base_url: "http://127.0.0.1:6007"
-        service_url: "http://127.0.0.1:6007/rerank"
+        instances:
+          default:
+            base_url: "http://127.0.0.1:6007"
+            service_url: "http://127.0.0.1:6007/rerank"
+          fine:
+            base_url: "http://127.0.0.1:6009"
+            service_url: "http://127.0.0.1:6009/rerank"
     request:
       max_docs: 1000
       normalize: true
-    # 服务内后端（reranker 进程启动时读取）
-    backend: "qwen3_vllm_score"  # bge | jina_reranker_v3 | qwen3_vllm | qwen3_vllm_score | qwen3_transformers | qwen3_transformers_packed | qwen3_gguf | qwen3_gguf_06b | dashscope_rerank
+    default_instance: "default"
+    # 命名实例：同一套 reranker 代码按实例名读取不同端口 / 后端 / runtime 目录。
+    instances:
+      default:
+        host: "0.0.0.0"
+        port: 6007
+        backend: "qwen3_vllm_score"
+        runtime_dir: "./.runtime/reranker/default"
+      fine:
+        host: "0.0.0.0"
+        port: 6009
+        backend: "bge"
+        runtime_dir: "./.runtime/reranker/fine"
     backends:
       bge:
         model_name: "BAAI/bge-reranker-v2-m3"
@@ -10,6 +10,7 @@ from __future__ import annotations
 from typing import Any, Dict
 from config.loader import get_app_config
+from config.services_config import get_rerank_service_url
 def _app():
@@ -92,10 +93,7 @@ INDEXER_BASE_URL = (
 )
 EMBEDDING_TEXT_SERVICE_URL = _app().services.embedding.get_provider_config().get("text_base_url")
 EMBEDDING_IMAGE_SERVICE_URL = _app().services.embedding.get_provider_config().get("image_base_url")
-RERANKER_SERVICE_URL = (
-    _app().services.rerank.get_provider_config().get("service_url")
-    or _app().services.rerank.get_provider_config().get("base_url")
-)
+RERANKER_SERVICE_URL = get_rerank_service_url()
 def get_es_config() -> Dict[str, Any]:
@@ -27,10 +27,13 @@ except Exception:  # pragma: no cover
 from config.schema import (
     AppConfig,
     AssetsConfig,
+    CoarseRankConfig,
+    CoarseRankFusionConfig,
     ConfigMetadata,
     DatabaseSettings,
     ElasticsearchSettings,
     EmbeddingServiceConfig,
+    FineRankConfig,
     FunctionScoreConfig,
     IndexConfig,
     InfrastructureConfig,
@@ -40,6 +43,7 @@ from config.schema import (
     RerankConfig,
     RerankFusionConfig,
     RerankServiceConfig,
+    RerankServiceInstanceConfig,
     RuntimeConfig,
     SearchConfig,
     SecretsConfig,
@@ -376,7 +380,20 @@ class AppConfigLoader:
             text_embedding_field=query_cfg.get("text_embedding_field"),
             image_embedding_field=query_cfg.get("image_embedding_field"),
             source_fields=query_cfg.get("source_fields"),
-            knn_boost=float(query_cfg.get("knn_boost", 0.25)),
+            knn_text_boost=float(
+                query_cfg.get("knn_text_boost", query_cfg.get("knn_boost", 0.25))
+            ),
+            knn_image_boost=float(
+                query_cfg.get("knn_image_boost", query_cfg.get("knn_boost", 0.25))
+            ),
+            knn_text_k=int(query_cfg.get("knn_text_k", 120)),
+            knn_text_num_candidates=int(query_cfg.get("knn_text_num_candidates", 400)),
+            knn_text_k_long=int(query_cfg.get("knn_text_k_long", 160)),
+            knn_text_num_candidates_long=int(
+                query_cfg.get("knn_text_num_candidates_long", 500)
+            ),
+            knn_image_k=int(query_cfg.get("knn_image_k", 120)),
+            knn_image_num_candidates=int(query_cfg.get("knn_image_num_candidates", 400)),
             multilingual_fields=list(
                 search_fields.get(
                     "multilingual_fields",
@@ -451,6 +468,11 @@ class AppConfigLoader:
         )
         function_score_cfg = raw.get("function_score") if isinstance(raw.get("function_score"), dict) else {}
+        coarse_rank_cfg = raw.get("coarse_rank") if isinstance(raw.get("coarse_rank"), dict) else {}
+        coarse_fusion_raw = (
+            coarse_rank_cfg.get("fusion") if isinstance(coarse_rank_cfg.get("fusion"), dict) else {}
+        )
+        fine_rank_cfg = raw.get("fine_rank") if isinstance(raw.get("fine_rank"), dict) else {}
         rerank_cfg = raw.get("rerank") if isinstance(raw.get("rerank"), dict) else {}
         fusion_raw = rerank_cfg.get("fusion") if isinstance(rerank_cfg.get("fusion"), dict) else {}
         spu_cfg = raw.get("spu_config") if isinstance(raw.get("spu_config"), dict) else {}
@@ -464,6 +486,33 @@ class AppConfigLoader:
                 boost_mode=str(function_score_cfg.get("boost_mode") or "multiply"),
                 functions=list(function_score_cfg.get("functions") or []),
             ),
+            coarse_rank=CoarseRankConfig(
+                enabled=bool(coarse_rank_cfg.get("enabled", True)),
+                input_window=int(coarse_rank_cfg.get("input_window", 700)),
+                output_window=int(coarse_rank_cfg.get("output_window", 240)),
+                fusion=CoarseRankFusionConfig(
+                    text_bias=float(coarse_fusion_raw.get("text_bias", 0.1)),
+                    text_exponent=float(coarse_fusion_raw.get("text_exponent", 0.35)),
+                    knn_text_weight=float(coarse_fusion_raw.get("knn_text_weight", 1.0)),
+                    knn_image_weight=float(coarse_fusion_raw.get("knn_image_weight", 1.0)),
+                    knn_tie_breaker=float(coarse_fusion_raw.get("knn_tie_breaker", 0.0)),
+                    knn_bias=float(coarse_fusion_raw.get("knn_bias", 0.6)),
+                    knn_exponent=float(coarse_fusion_raw.get("knn_exponent", 0.2)),
+                ),
+            ),
+            fine_rank=FineRankConfig(
+                enabled=bool(fine_rank_cfg.get("enabled", True)),
+                input_window=int(fine_rank_cfg.get("input_window", 240)),
+                output_window=int(fine_rank_cfg.get("output_window", 80)),
+                timeout_sec=float(fine_rank_cfg.get("timeout_sec", 10.0)),
+                rerank_query_template=str(fine_rank_cfg.get("rerank_query_template") or "{query}"),
+                rerank_doc_template=str(fine_rank_cfg.get("rerank_doc_template") or "{title}"),
+                service_profile=(
+                    str(v)
+                    if (v := fine_rank_cfg.get("service_profile")) not in (None, "")
+                    else "fine"
+                ),
+            ),
             rerank=RerankConfig(
                 enabled=bool(rerank_cfg.get("enabled", True)),
                 rerank_window=int(rerank_cfg.get("rerank_window", 384)),
@@ -472,6 +521,11 @@ class AppConfigLoader:
                 weight_ai=float(rerank_cfg.get("weight_ai", 0.6)),
                 rerank_query_template=str(rerank_cfg.get("rerank_query_template") or "{query}"),
                 rerank_doc_template=str(rerank_cfg.get("rerank_doc_template") or "{title}"),
+                service_profile=(
+                    str(v)
+                    if (v := rerank_cfg.get("service_profile")) not in (None, "")
+                    else None
+                ),
                 fusion=RerankFusionConfig(
                     rerank_bias=float(fusion_raw.get("rerank_bias", 0.00001)),
                     rerank_exponent=float(fusion_raw.get("rerank_exponent", 1.0)),
@@ -482,6 +536,8 @@ class AppConfigLoader:
                     knn_tie_breaker=float(fusion_raw.get("knn_tie_breaker", 0.0)),
                     knn_bias=float(fusion_raw.get("knn_bias", 0.6)),
                     knn_exponent=float(fusion_raw.get("knn_exponent", 0.2)),
+                    fine_bias=float(fusion_raw.get("fine_bias", 0.00001)),
+                    fine_exponent=float(fusion_raw.get("fine_exponent", 1.0)),
                 ),
             ),
             spu_config=SPUConfig(
@@ -560,13 +616,61 @@ class AppConfigLoader:
         rerank_providers = dict(rerank_raw.get("providers") or {})
         if rerank_provider not in rerank_providers:
             raise ConfigurationError(f"services.rerank.providers.{rerank_provider} must be configured")
-        rerank_backend = str(rerank_raw.get("backend") or "").strip().lower()
         rerank_backends = {
             str(key).strip().lower(): dict(value)
             for key, value in dict(rerank_raw.get("backends") or {}).items()
         }
-        if rerank_backend not in rerank_backends:
-            raise ConfigurationError(f"services.rerank.backends.{rerank_backend} must be configured")
+        default_instance = str(rerank_raw.get("default_instance") or "default").strip() or "default"
+        raw_instances = rerank_raw.get("instances") if isinstance(rerank_raw.get("instances"), dict) else {}
+        if not raw_instances:
+            legacy_backend = str(rerank_raw.get("backend") or "").strip().lower()
+            if legacy_backend not in rerank_backends:
+                raise ConfigurationError(f"services.rerank.backends.{legacy_backend} must be configured")
+            provider_cfg = dict(rerank_providers.get(rerank_provider) or {})
+            raw_instances = {
+                default_instance: {
+                    "host": "0.0.0.0",
+                    "port": 6007,
+                    "backend": legacy_backend,
+                    "base_url": provider_cfg.get("base_url"),
+                    "service_url": provider_cfg.get("service_url"),
+                }
+            }
+        rerank_instances = {}
+        for instance_name, instance_raw in raw_instances.items():
+            if not isinstance(instance_raw, dict):
+                raise ConfigurationError(f"services.rerank.instances.{instance_name} must be a mapping")
+            normalized_instance_name = str(instance_name).strip()
+            backend_name = str(instance_raw.get("backend") or "").strip().lower()
+            if backend_name not in rerank_backends:
+                raise ConfigurationError(
+                    f"services.rerank.instances.{normalized_instance_name}.backend must reference configured services.rerank.backends"
+                )
+            port = int(instance_raw.get("port", 6007))
+            rerank_instances[normalized_instance_name] = RerankServiceInstanceConfig(
+                host=str(instance_raw.get("host") or "0.0.0.0"),
+                port=port,
+                backend=backend_name,
+                runtime_dir=(
+                    str(v)
+                    if (v := instance_raw.get("runtime_dir")) not in (None, "")
+                    else None
+                ),
+                base_url=(
+                    str(v).rstrip("/")
+                    if (v := instance_raw.get("base_url")) not in (None, "")
+                    else None
+                ),
+                service_url=(
+                    str(v).rstrip("/")
+                    if (v := instance_raw.get("service_url")) not in (None, "")
+                    else None
+                ),
+            )
+        if default_instance not in rerank_instances:
+            raise ConfigurationError(
+                f"services.rerank.default_instance={default_instance!r} must exist in services.rerank.instances"
+            )
         rerank_request = dict(rerank_raw.get("request") or {})
         rerank_request.setdefault("max_docs", 1000)
         rerank_request.setdefault("normalize", True)
@@ -574,7 +678,8 @@ class AppConfigLoader:
         rerank_config = RerankServiceConfig(
             provider=rerank_provider,
             providers=rerank_providers,
-            backend=rerank_backend,
+            default_instance=default_instance,
+            instances=rerank_instances,
             backends=rerank_backends,
             request=rerank_request,
         )
@@ -699,8 +804,19 @@ class AppConfigLoader:
             errors.append("services.embedding.providers.<provider>.image_base_url is required")
         rerank_provider_cfg = app_config.services.rerank.get_provider_config()
-        if not rerank_provider_cfg.get("service_url") and not rerank_provider_cfg.get("base_url"):
-            errors.append("services.rerank.providers.<provider>.service_url or base_url is required")
+        provider_instances = rerank_provider_cfg.get("instances")
+        if not isinstance(provider_instances, dict):
+            provider_instances = {}
+        for instance_name in app_config.services.rerank.instances:
+            instance_cfg = app_config.services.rerank.get_instance(instance_name)
+            provider_instance_cfg = provider_instances.get(instance_name) if isinstance(provider_instances, dict) else None
+            has_instance_url = False
+            if isinstance(provider_instance_cfg, dict):
+                has_instance_url = bool(provider_instance_cfg.get("service_url") or provider_instance_cfg.get("base_url"))
+            if not has_instance_url and not instance_cfg.service_url and not instance_cfg.base_url:
+                errors.append(
+                    f"services.rerank instance {instance_name!r} must define service_url/base_url either under providers.<provider>.instances or services.rerank.instances"
+                )
         if errors:
             raise ConfigurationError("Configuration validation failed:\n" + "\n".join(f"  - {err}" for err in errors))
@@ -34,7 +34,15 @@ class QueryConfig:
     text_embedding_field: Optional[str] = "title_embedding"
     image_embedding_field: Optional[str] = None
     source_fields: Optional[List[str]] = None
-    knn_boost: float = 0.25
+    # 文本向量 KNN 与多模态（图片）向量 KNN 各自 boost；未在 YAML 中写时由 loader 用 legacy knn_boost 回填
+    knn_text_boost: float = 20.0
+    knn_image_boost: float = 20.0
+    knn_text_k: int = 120
+    knn_text_num_candidates: int = 400
+    knn_text_k_long: int = 160
+    knn_text_num_candidates_long: int = 500
+    knn_image_k: int = 120
+    knn_image_num_candidates: int = 400
     multilingual_fields: List[str] = field(
         default_factory=lambda: []
     )
@@ -109,6 +117,48 @@ class RerankFusionConfig:
     knn_tie_breaker: float = 0.0
     knn_bias: float = 0.6
     knn_exponent: float = 0.2
+    fine_bias: float = 0.00001
+    fine_exponent: float = 1.0
+
+
+@dataclass(frozen=True)
+class CoarseRankFusionConfig:
+    """
+    Multiplicative fusion without model score:
+    fused = (max(text, 0) + text_bias) ** text_exponent
+            * (max(knn, 0) + knn_bias) ** knn_exponent
+    """
+
+    text_bias: float = 0.1
+    text_exponent: float = 0.35
+    knn_text_weight: float = 1.0
+    knn_image_weight: float = 1.0
+    knn_tie_breaker: float = 0.0
+    knn_bias: float = 0.6
+    knn_exponent: float = 0.2
+
+
+@dataclass(frozen=True)
+class CoarseRankConfig:
+    """Search-time coarse ranking configuration."""
+
+    enabled: bool = True
+    input_window: int = 700
+    output_window: int = 240
+    fusion: CoarseRankFusionConfig = field(default_factory=CoarseRankFusionConfig)
+
+
+@dataclass(frozen=True)
+class FineRankConfig:
+    """Search-time lightweight rerank configuration."""
+
+    enabled: bool = True
+    input_window: int = 240
+    output_window: int = 80
+    timeout_sec: float = 10.0
+    rerank_query_template: str = "{query}"
+    rerank_doc_template: str = "{title}"
+    service_profile: Optional[str] = "fine"
 @dataclass(frozen=True)
@@ -122,6 +172,7 @@ class RerankConfig:
     weight_ai: float = 0.6
     rerank_query_template: str = "{query}"
     rerank_doc_template: str = "{title}"
+    service_profile: Optional[str] = None
     fusion: RerankFusionConfig = field(default_factory=RerankFusionConfig)
@@ -133,6 +184,8 @@ class SearchConfig:
     indexes: List[IndexConfig] = field(default_factory=list)
     query_config: QueryConfig = field(default_factory=QueryConfig)
     function_score: FunctionScoreConfig = field(default_factory=FunctionScoreConfig)
+    coarse_rank: CoarseRankConfig = field(default_factory=CoarseRankConfig)
+    fine_rank: FineRankConfig = field(default_factory=FineRankConfig)
     rerank: RerankConfig = field(default_factory=RerankConfig)
     spu_config: SPUConfig = field(default_factory=SPUConfig)
     es_index_name: str = "search_products"
@@ -183,20 +236,41 @@ class EmbeddingServiceConfig:
 @dataclass(frozen=True)
+class RerankServiceInstanceConfig:
+    """One named reranker service instance."""
+
+    host: str = "0.0.0.0"
+    port: int = 6007
+    backend: str = "qwen3_vllm_score"
+    runtime_dir: Optional[str] = None
+    base_url: Optional[str] = None
+    service_url: Optional[str] = None
+
+
+@dataclass(frozen=True)
 class RerankServiceConfig:
     """Reranker service configuration."""
     provider: str
     providers: Dict[str, Any]
-    backend: str
+    default_instance: str
+    instances: Dict[str, RerankServiceInstanceConfig]
     backends: Dict[str, Dict[str, Any]]
     request: Dict[str, Any]
     def get_provider_config(self) -> Dict[str, Any]:
         return dict(self.providers.get(self.provider, {}) or {})
-    def get_backend_config(self) -> Dict[str, Any]:
-        return dict(self.backends.get(self.backend, {}) or {})
+    def get_instance(self, name: Optional[str] = None) -> RerankServiceInstanceConfig:
+        instance_name = str(name or self.default_instance).strip() or self.default_instance
+        instance = self.instances.get(instance_name)
+        if instance is None:
+            raise KeyError(f"Unknown rerank service instance: {instance_name!r}")
+        return instance
+
+    def get_backend_config(self, name: Optional[str] = None) -> Dict[str, Any]:
+        instance = self.get_instance(name)
+        return dict(self.backends.get(instance.backend, {}) or {})
 @dataclass(frozen=True)
@@ -11,7 +11,12 @@ import os
 from typing import Any, Dict, Tuple
 from config.loader import get_app_config
-from config.schema import EmbeddingServiceConfig, RerankServiceConfig, TranslationServiceConfig
+from config.schema import (
+    EmbeddingServiceConfig,
+    RerankServiceConfig,
+    RerankServiceInstanceConfig,
+    TranslationServiceConfig,
+)
 def get_translation_config() -> Dict[str, Any]:
@@ -26,6 +31,16 @@ def get_rerank_config() -&gt; RerankServiceConfig:
     return get_app_config().services.rerank
+def get_rerank_instance_config(profile: str | None = None) -> RerankServiceInstanceConfig:
+    cfg = get_app_config().services.rerank
+    instance_name = str(
+        profile
+        or os.getenv("RERANK_INSTANCE")
+        or cfg.default_instance
+    ).strip() or cfg.default_instance
+    return cfg.get_instance(instance_name)
+
+
 def get_translation_base_url() -> str:
     return get_app_config().services.translation.endpoint
@@ -60,24 +75,56 @@ def get_embedding_image_backend_config() -&gt; Tuple[str, Dict[str, Any]]:
     return cfg.image_backend, cfg.get_image_backend_config()
-def get_rerank_backend_config() -> Tuple[str, Dict[str, Any]]:
+def get_rerank_backend_config(profile: str | None = None) -> Tuple[str, Dict[str, Any]]:
     cfg = get_app_config().services.rerank
-    backend = str(os.getenv("RERANK_BACKEND") or cfg.backend).strip()
-    if backend != cfg.backend:
+    instance = get_rerank_instance_config(profile)
+    backend = str(os.getenv("RERANK_BACKEND") or instance.backend).strip()
+    if backend != instance.backend:
         backend_cfg = cfg.backends.get(backend)
         if backend_cfg is None:
             raise ValueError(f"Unknown rerank backend override from RERANK_BACKEND: {backend!r}")
         return backend, dict(backend_cfg)
-    return cfg.backend, cfg.get_backend_config()
+    return instance.backend, cfg.get_backend_config(profile)
-def get_rerank_base_url() -> str:
-    provider_cfg = get_app_config().services.rerank.get_provider_config()
-    base = provider_cfg.get("service_url") or provider_cfg.get("base_url")
+def get_rerank_base_url(profile: str | None = None) -> str:
+    cfg = get_app_config().services.rerank
+    instance = get_rerank_instance_config(profile)
+    provider_cfg = cfg.get_provider_config()
+    profile_name = str(profile or os.getenv("RERANK_INSTANCE") or cfg.default_instance).strip() or cfg.default_instance
+
+    base = None
+    provider_instances = provider_cfg.get("instances")
+    if isinstance(provider_instances, dict):
+        instance_provider_cfg = provider_instances.get(profile_name)
+        if isinstance(instance_provider_cfg, dict):
+            base = instance_provider_cfg.get("base_url") or instance_provider_cfg.get("service_url")
+    if not base:
+        base = instance.base_url or instance.service_url
+    if not base:
+        base = provider_cfg.get("service_url") or provider_cfg.get("base_url")
     if not base:
         raise ValueError("Rerank service URL is not configured")
-    return str(base).rstrip("/")
+    base = str(base).rstrip("/")
+    if base.endswith("/rerank"):
+        base = base[: -len("/rerank")]
+    return base
-def get_rerank_service_url() -> str:
-    return get_rerank_base_url()
+def get_rerank_service_url(profile: str | None = None) -> str:
+    cfg = get_app_config().services.rerank
+    instance = get_rerank_instance_config(profile)
+    provider_cfg = cfg.get_provider_config()
+    profile_name = str(profile or os.getenv("RERANK_INSTANCE") or cfg.default_instance).strip() or cfg.default_instance
+
+    service_url = None
+    provider_instances = provider_cfg.get("instances")
+    if isinstance(provider_instances, dict):
+        instance_provider_cfg = provider_instances.get(profile_name)
+        if isinstance(instance_provider_cfg, dict):
+            service_url = instance_provider_cfg.get("service_url")
+    if not service_url:
+        service_url = instance.service_url
+    if not service_url:
+        service_url = f"{get_rerank_base_url(profile=profile)}/rerank"
+    return str(service_url).rstrip("/")
@@ -26,6 +26,8 @@ class RequestContextStage(Enum):
     # ES 按 ID 回源分页详情回填
     ELASTICSEARCH_PAGE_FILL = "elasticsearch_page_fill"
     RESULT_PROCESSING = "result_processing"
+    COARSE_RANKING = "coarse_ranking"
+    FINE_RANKING = "fine_ranking"
     RERANKING = "reranking"
     # 款式意图 SKU 预筛选（StyleSkuSelector.prepare_hits）
     STYLE_SKU_PREPARE_HITS = "style_sku_prepare_hits"
@@ -407,4 +409,4 @@ def clear_current_request_context() -&gt; None:
         reset_request_log_context(tokens)
         delattr(threading.current_thread(), 'request_log_tokens')
     if hasattr(threading.current_thread(), 'request_context'):
-        delattr(threading.current_thread(), 'request_context')
 \ No newline at end of file
+        delattr(threading.current_thread(), 'request_context')
@@ -0,0 +1,72 @@
+目前knn跟query里面是并列的层级，如下：
+{
+  "size": 400,
+  "from": 0,
+  "query": {
+    "bool": {
+      "must": [...
+      ],
+    }
+  },
+  "knn": {
+    "field": "title_embedding",
+    "query_vector": [...],
+    "k": 120,
+    "num_candidates": 400,
+    "boost": 2,
+    "_name": "knn_query"
+  },
+其中query的结构是这样的：  
+"query": {
+    "bool": {
+      "should": [
+        {
+          "bool": {
+            "_name": "base_query", 
+\# 原始query
+          }
+        },
+        {
+          "bool": {
+            "_name": "base_query_trans_zh",
+\# 翻译query。有可能是base_query_trans_en，也有可能两者都有
+            "boost": 0.75
+          }
+        }
+      ],
+      "minimum_should_match": 1
+    }
+  },
+我想把knn放到should里面，和base_query、base_query_trans_zh并列。
+另外，现在过滤是在knn里面单独加了一遍：
+  "knn": {
+    "field": "title_embedding",
+    "query_vector": [...],
+    "k": 120,
+    "num_candidates": 400,
+    "boost": 2,
+    "_name": "knn_query",
+    "filter": {
+      "range": {
+        "min_price": {
+          "gte": 100,
+          "lt": 200
+        }
+      }
+    }
+  }
+现在不需要了。因为knn在query的内层了。共用过滤。
+
+另外：
+我需要再增加一个knn。
+需要参考文本embedding获得的逻辑，
+通过
+curl -X POST "http://localhost:6008/embed/clip_text?normalize=true&priority=1" \
+  -H "Content-Type: application/json" \
+  -d '["纯棉短袖", "street tee"]'
+（用 POST /embed/clip_text 生成多模态文本向量。和文本embedding获取方法类似。注意思考代码如何精简，不要冗余。）
+得到文本的多模态embedding。
+然后在这里补充一个多模态embedding，寻找图片相似的结果，对应的商品图片字段为image_embedding.vector。
+重排融合：之前有knn的配置bias和exponential。现在，文本和图片的embedding相似需要融合，融合方式是dis_max，因此需要配置：
+1）各自的权重和tie_breaker
+2）整个向量方面的权重（bias和exponential）
 \ No newline at end of file
@@ -0,0 +1,93 @@
+@query/query_parser.py @scripts/es_debug_search.py 
+原始query、以及每一个翻译，都要有一个对应的keywords_query（token分词后，得到名词）
+参考这段代码，获取每一个长度大于 1 的名词，然后用空格拼接起来，作为keywords_query
+import hanlp
+from typing import List, Tuple, Dict, Any
+
+class KeywordExtractor:
+    """
+    基于 HanLP 的名词关键词提取器
+    """
+    def __init__(self):
+        # 加载带位置信息的分词模型（细粒度）
+        self.tok = hanlp.load(hanlp.pretrained.tok.CTB9_TOK_ELECTRA_BASE_CRF)
+        self.tok.config.output_spans = True   # 启用位置输出
+        
+        # 加载词性标注模型
+        self.pos_tag = hanlp.load(hanlp.pretrained.pos.CTB9_POS_ELECTRA_SMALL)
+        
+    def extract_keywords(self, query: str) -> str:
+        """
+        从查询中提取关键词（名词，长度 ≥ 2）
+        
+        Args:
+            query: 输入文本
+            
+        Returns:
+            拼接后的关键词字符串，非连续词之间自动插入空格
+        """
+        query = query.strip()
+        # 分词结果带位置：[[word, start, end], ...]
+        tok_result_with_position = self.tok(query)
+        tok_result = [x[0] for x in tok_result_with_position]
+        
+        # 词性标注
+        pos_tag_result = list(zip(tok_result, self.pos_tag(tok_result)))
+        
+        # 需要忽略的词
+        ignore_keywords = ['玩具']
+        
+        keywords = []
+        last_end_pos = 0
+        
+        for (word, postag), (_, start_pos, end_pos) in zip(pos_tag_result, tok_result_with_position):
+            if len(word) >= 2 and postag.startswith('N'):
+                if word in ignore_keywords:
+                    continue
+                # 如果当前词与上一个词在原文中不连续，插入空格
+                if start_pos != last_end_pos and keywords:
+                    keywords.append(" ")
+                keywords.append(word)
+                last_end_pos = end_pos
+            # 可选：打印调试信息
+            # print(f'分词: {word} | 词性: {postag} | 起始: {start_pos} | 结束: {end_pos}')
+        
+        return "".join(keywords).strip()
+
+
+最后，在组织检索表达式时，目前是每一个 query （base_query base_query_trans_en base_query_trans_zh 三种情况）。 会组成一个bool查询，以base_query为例：
+    "bool": {
+      "should": [
+        {
+          "bool": {
+            "_name": "base_query",
+            "must": [
+              {
+                "combined_fields": {
+...
+                }
+              }
+            ],
+            "should": [
+              {
+                "multi_match": {
+...                  "type": "best_fields",
+...
+              },
+              {
+                "multi_match": {
+...
+                  "type": "phrase",
+...
+                }
+              }
+            ]
+          }
+        },
+
+base_query_trans_en base_query_trans_zh 也是同样
+
+在这个布尔查询的must里面加一项：keywords，搜索的字段和combined_fields一样，命中比例要求50%
+
+
+结合现有代码做出合理的设计，呈现简单清晰的数据接口，而不是打补丁
 \ No newline at end of file
@@ -0,0 +1,38 @@
+这是上一轮检索效果优化的需求：
+参考
+searcher.py 
+rerank_client.py 
+schema.py 
+es_query_builder.py 
+config.yaml 
+相关性检索优化说明.md 
+
+在ES返回到rerank期间增加一轮粗排+一轮精排。
+1. ES召回，600
+2. 粗排：600->240。配置文件增加粗排相关配置，包括输入条数（配置为700，ES拉取的条数改为粗排输入条数），然后增加粗排的融合公式配置，参考现有的reranker融合公式即可、只是去掉其中的重排模型项。
+3. 现在的sku选择、为reranker生成title后缀这一套逻辑，是放在粗排后，因为精排也是一个reranker模型（只不过是一个轻量级的，bge-reranker），需要用这个title后缀。
+4. 精排：240-80，使用bge-reranker，但是，因为reranker只能选一个backend，考虑如何重构。现在，精排也是一个独立的进程、独立提供端口，服务。但是，因为跟重排逻辑是一致的（即使有部分不一致也应该分离不一致的点进行配置化），所以共用代码，只是根据需要启动两个实例，避免代码冗余。
+5. 重排：80，也是用当前的重排代码，调用单独的实例（即现在使用的实例），返回后，经过融合公式，到分页，也参考现在的融合公式，但是，加入一项精排模型打分。
+测试时，使用跟我同样的环境./scripts/service_ctl.sh reranker backend 重启相关服务进行测试
+
+你已经完成了一般修改，已把三段排序链路接上了，主改动在 search/searcher.py、search/rerank_client.py、config/schema.py、config/loader.py、config/services_config.py 和 config/config.yaml。
+
+现在链路是：
+ES 拉取 coarse_rank.input_window 条 -> 粗排按 text/knn 融合裁到 coarse_rank.output_window -> 再做 SKU 选择和 title suffix -> 精排调用轻量 reranker 裁到 fine_rank.output_window -> 最终重排调用现有 reranker，并在最终融合里加入 fine_score。同时把 reranker client/provider 改成了按 service_profile 选不同 service_url，这样 fine/final 可以共用同一套服务代码，只起不同实例。
+
+你是用了./.venv/bin/pytest -q tests/test_rerank_client.py tests/test_search_rerank_window.py 进行验证，结果是 18 passed。也按要求尝试了 ./scripts/service_ctl.sh restart reranker backend 做联调，但当前环境里只有 6007 的现有 reranker，配置里的 fine 端口 6009 还没对应实例，而且服务重启后进程状态不太稳定，没能完成完整线上链路验证。当前最关键的落地前置是把轻量 bge 实例补起来，再用同样脚本重启联调。
+
+因此，需要回顾这个漏斗的代码，进行进一步的优化：
+1. Fine Rank环节的信息都是N/A。fine 实例也需要在config.yaml中体现，并且需要被server_ctl.sh管理，参考现在是怎么管理reranker的。fine和reranker分别调用哪个模型（两者代码功能，但是只是启动不同的实例），请你深度思考后决定。这里是需要参考当前代码、根据实际需要（原来只有一个reranker、现在多了一个精排，也要调用一个重排模型，因此带来的必要的部分重构。
+2. Ranking Funnel、Fusion Factors、Signal Breakdown
+这些是不是整合起来、按漏斗收集、整理信息、以及进行呈现比较好。
+ES 召回的环节，展示Matched Queries各项打分、ES的总分、norm后打分、排序位置，等等关键信息
+粗排：粗排融合公式的各项输入、重要中间结果和参数、最后得分，排序位置以及上升/下降了多少。等等关键信息。
+精排：同样例举关键的输入、中间过程、输出、排序和位置变化等。
+reranker：类似
+
+因为涉及的环节较多，非常要注意的一个点是：不要每次修改都在原来的基础上，为实现目标而打补丁，应该观察一下所涉及的代码现在是怎么做的，务必注意如何适当的清理掉现有逻辑，该如何对其进行修改，来达到目的，以达到代码的精简，避免冗余、分叉。
+特别是1关于将现在的单独的reranker服务，在不增加代码复杂度的情况下，如何可以通过配置启动多个实例、各自可以配置选择的模型等相关参数、分别服务于精排和重排，是设计的重中之重。这里需要思考配置如何拆分，需要多读相关代码、思考最佳实践。
+
+
+
@@ -0,0 +1,136 @@
+我：
+进行一轮检索效果优化：
+参考
+[searcher.py](search/searcher.py) 
+[rerank_client.py](search/rerank_client.py) 
+[schema.py](config/schema.py) 
+[es_query_builder.py](search/es_query_builder.py) 
+[config.yaml](config/config.yaml) 
+[相关性检索优化说明.md](docs/相关性检索优化说明.md) 
+
+在ES返回到rerank期间增加一轮粗排+一轮精排。
+1. ES召回，600
+2. 粗排：600->240。配置文件增加粗排相关配置，包括输入条数（配置为700，ES拉取的条数改为粗排输入条数），然后增加粗排的融合公式配置，参考现有的reranker融合公式即可、只是去掉其中的重排模型项。
+3. 现在的sku选择、为reranker生成title后缀这一套逻辑，是放在粗排后，因为精排也是一个reranker模型（只不过是一个轻量级的，bge-reranker），需要用这个title后缀。
+4. 精排：240-80，使用bge-reranker，但是，因为reranker只能选一个backend，考虑如何重构。现在，精排也是一个独立的进程、独立提供端口，服务。但是，因为跟重排逻辑是一致的（即使有部分不一致也应该分离不一致的点进行配置化），所以共用代码，只是根据需要启动两个实例，避免代码冗余。
+5. 重排：80，也是用当前的重排代码，调用单独的实例（即现在使用的实例），返回后，经过融合公式，到分页，也参考现在的融合公式，但是，加入一项精排模型打分。
+测试时，使用跟我同样的环境./scripts/service_ctl.sh reranker backend 重启相关服务进行测试
+
+
+
+
+
+codex：
+前端这轮我把调试展示重构成了“两层漏斗”：
+
+1. 整体漏斗
+在 [frontend/static/js/app.js](/data/saas-search/frontend/static/js/app.js) 里把原来散着的 `Query Analysis / Rerank / Stage Timings / ES Query` 重新组织成了：
+- `Query Context`
+- `Ranking Funnel`
+- `Timing Breakdown`
+- `Raw Payloads`
+
+其中 `Ranking Funnel` 现在按阶段卡片展示：
+- `ES Recall`
+- `Coarse Rank`
+- `Fine Rank`
+- `Final Rerank`
+- `Page Return`
+
+每张卡都尽量只放调参最关键的信息：输入/输出条数、模板、service URL、top_n、fusion/meta。这样你看漏斗收缩、看每段服务表现、看融合参数会更直接。
+
+2. 单条结果漏斗
+在结果卡片右侧的 debug 区，我改成了真正的单条漏斗卡片，按“分数结果”和“公式分解”分开看：
+- 顶部先看 `Initial Rank / Final Rank / Rank Delta`
+- 再看阶段分数：`ES / ES Norm / Coarse / Fine / Rerank / Fused`
+- 再看融合因子：`coarse_text_factor / coarse_knn_factor / text_factor / knn_factor / fine_factor / rerank_factor`
+- 再看信号拆解：`text_source / text_translation / text_primary / text_support / text_knn / image_knn`
+
+同时保留了可展开的：
+- `Rerank Input`
+- `Selected SKU`
+- `Matched Queries`
+- `Multilingual Fields`
+
+为了支撑前端，我顺手在 [search/searcher.py](/data/saas-search/search/searcher.py) 里补了单条 `coarse_score / coarse_text_factor / coarse_knn_factor` 到 `per_result`，这样单条卡片现在能把粗排也完整展示出来。
+
+样式上在 [frontend/static/css/style.css](/data/saas-search/frontend/static/css/style.css) 加了阶段卡片、分数 pill、时延条形图和移动端适配。JS 语法我用 `node --check frontend/static/js/app.js` 过了，后端补充字段也用 `./.venv/bin/python -m py_compile search/searcher.py` 过了。
+
+如果你愿意，我下一步可以继续把这个视图再往“调参工作台”方向推一层，比如再加：
+- 漏斗阶段间的 drop rate
+- 每条结果的 rank jump 高亮
+- 批量对比 top N 结果里某个因子分布
+- fusion 参数和结果联动的可视化摘要
+
+
+
+
+
+
+
+
+我：
+1. Fine Rank环节的信息都是N/A，是没有配置吗。fine rank是使用bge-reranker，复用当前reranker模型的代码，但是需要单独起一个服务、单独加载一个模型。
+2. Ranking Funnel、Fusion Factors、Signal Breakdown
+这些是不是整合起来、按漏斗收集、整理信息、以及进行呈现比较好。
+ES 召回的环节，展示Matched Queries各项打分、ES的总分、norm后打分、排序位置，等等关键信息
+粗排：粗排融合公式的各项输入、重要中间结果和参数、最后得分，排序位置以及上升/下降了多少。等等关键信息。
+精排：同样例举关键的输入、中间过程、输出、排序和位置变化等。
+reranker：类似
+
+因为涉及的环节较多，非常要注意的一个点是：不要每次修改都在原来的基础上，为实现目标而打补丁，应该观察一下所涉及的代码现在是怎么做的，务必注意如何适当的清理掉现有逻辑，该如何对其进行修改，来达到目的，以达到代码的精简，避免冗余、分叉。
+
+
+
+
+
+
+codex：
+`Fine Rank` 之前显示 `N/A`，根因不是前端单纯没写，而是后端原来只有“精排成功拿到分数”时才会填那块 debug；一旦 `fine` 服务没起、没配 `service_url`、调用失败，前端只能看到空值。现在我把这层补齐了：
+
+- 顶层 `debug_info.fine_rank` 现在会始终带 `status / service_profile / service_url / input_window / output_window / query_template / doc_template`
+- 失败时会带 `error`
+- 成功时再补 `docs / top_n / meta`
+- 所以你现在能区分：
+  - `disabled`
+  - `pending`
+  - `ok`
+  - `failed_no_scores`
+  - `failed`
+
+也就是说，`fine rank` 本身仍然需要你按设计单独起一个 `bge-reranker` 实例，这一层代码已经按“独立服务 + 共用 reranker 代码”的方式接好了，但服务本身还是要单独启动。
+
+这轮我也把调试展示做了结构化重构，不再继续在旧视图上打补丁。现在是按阶段组织信息：
+
+- 整体漏斗：
+  - `ES Recall`
+  - `Coarse Rank`
+  - `Fine Rank`
+  - `Final Rerank`
+  - `Page Return`
+- 单条结果：
+  - 用统一的 `ranking_funnel` 结构来表达每个阶段的
+  - `rank`
+  - `delta`
+  - `score`
+  - 关键中间量
+  - 关键 factor
+  - 输入 payload
+
+具体改动在：
+- [search/searcher.py](/data/saas-search/search/searcher.py)
+- [frontend/static/js/app.js](/data/saas-search/frontend/static/js/app.js)
+- [frontend/static/css/style.css](/data/saas-search/frontend/static/css/style.css)
+
+单条结果现在按 stage card 展示，而不是把 `Ranking Funnel / Fusion Factors / Signal Breakdown` 拆成三块平铺，这样你可以顺着 ES -> 粗排 -> 精排 -> rerank 看每段的输入、过程、输出和位次变化，更适合调融合公式。
+
+检查我也跑过了：
+- `node --check frontend/static/js/app.js`
+- `./.venv/bin/python -m py_compile search/searcher.py`
+- `./.venv/bin/pytest -q tests/test_search_rerank_window.py`
+
+都通过了。
+
+下一步如果你要，我建议直接继续做两件事中的一个：
+1. 把 `fine` 实例真正拉起来，然后我再把前端里 `status=failed/pending` 的场景跑成真实数据。
+2. 在当前漏斗视图上继续加“阶段 rank 分布 / delta 高亮 / topN 因子对比”，把它做成更像调参工作台。
 \ No newline at end of file
@@ -584,18 +584,14 @@ SELECT &#39;shoplazza_product_index_increment&#39;, COUNT(*) FROM shoplazza_product_inde
 "
 # 执行删除
-cd /data/saas-search && MYSQL_PWD='qY8tgodLoA&KT#yQ' mysql -h 10.200.16.14 -P 3316 -u root saas -N -e "
-SELECT 'shoplazza_sync_log', COUNT(*) FROM shoplazza_sync_log WHERE tenant_id = 163
-UNION ALL
-SELECT 'shoplazza_product_index_increment', COUNT(*) FROM shoplazza_product_index_increment WHERE tenant_id = 163;
+cd /data/saas-search && MYSQL_PWD='qY8tgodLoA&KT#yQ' mysql -h 10.200.16.14 -P 3316 -u root saas -e "
+SET SESSION sql_safe_updates = 0;
+DELETE FROM shoplazza_sync_log WHERE tenant_id = 163;
+SELECT ROW_COUNT() AS deleted_sync_log;
+DELETE FROM shoplazza_product_index_increment WHERE tenant_id = 163;
+SELECT ROW_COUNT() AS deleted_index_increment;
 "
-# 再次统计 tenant_id=163 的行数
-MYSQL_PWD='qY8tgodLoA&KT#yQ' mysql -h 10.200.16.14 -P 3316 -u root saas -N -e "
-SELECT 'shoplazza_sync_log', COUNT(*) FROM shoplazza_sync_log WHERE tenant_id = 163
-UNION ALL
-SELECT 'shoplazza_product_index_increment', COUNT(*) FROM shoplazza_product_index_increment WHERE tenant_id = 163;
-"
 ```
 然后触发重新安装：
@@ -357,16 +357,22 @@ body {
     color: #555;
     border-left: 1px dashed #eee;
     padding-left: 12px;
-    max-height: 260px;
+    max-height: 540px;
     overflow: auto;
 }
 .product-debug-title {
     font-weight: 600;
-    margin-bottom: 6px;
+    margin-bottom: 8px;
     color: #333;
 }
+.product-debug-subtitle {
+    margin: 10px 0 6px;
+    font-weight: 600;
+    color: #666;
+}
+
 .product-debug-line {
     margin-bottom: 2px;
 }
@@ -418,6 +424,191 @@ body {
     word-break: break-word;
 }
+.debug-panel {
+    display: flex;
+    flex-direction: column;
+    gap: 14px;
+    padding: 12px;
+    font-family: Menlo, Consolas, "Courier New", monospace;
+    font-size: 12px;
+}
+
+.debug-section-block {
+    background: #fff;
+    border: 1px solid #e8e8e8;
+    border-radius: 10px;
+    padding: 14px;
+}
+
+.debug-section-title {
+    font-size: 13px;
+    font-weight: 700;
+    color: #222;
+    margin-bottom: 10px;
+}
+
+.debug-stage-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(210px, 1fr));
+    gap: 12px;
+}
+
+.debug-stage-card {
+    border: 1px solid #ececec;
+    border-radius: 8px;
+    padding: 12px;
+    background: linear-gradient(180deg, #fff 0%, #fafafa 100%);
+}
+
+.debug-stage-title {
+    font-size: 13px;
+    font-weight: 700;
+    color: #333;
+}
+
+.debug-stage-subtitle {
+    margin: 4px 0 8px;
+    color: #888;
+    font-size: 11px;
+}
+
+.debug-metrics {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+    gap: 8px;
+}
+
+.debug-metric {
+    padding: 8px 9px;
+    background: #f7f7f7;
+    border-radius: 6px;
+    border: 1px solid #efefef;
+}
+
+.debug-metric-label {
+    font-size: 11px;
+    color: #777;
+    margin-bottom: 2px;
+}
+
+.debug-metric-value {
+    color: #222;
+    font-weight: 600;
+    word-break: break-word;
+}
+
+.debug-score-pills {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin-bottom: 6px;
+}
+
+.debug-score-pill {
+    display: inline-flex;
+    align-items: center;
+    gap: 8px;
+    padding: 6px 10px;
+    border-radius: 999px;
+    border: 1px solid #e3e3e3;
+    background: #f7f7f7;
+}
+
+.debug-score-pill-label {
+    color: #666;
+}
+
+.debug-score-pill-value {
+    color: #111;
+    font-weight: 700;
+}
+
+.tone-es {
+    background: #f8f1ff;
+    border-color: #e6d5ff;
+}
+
+.tone-coarse {
+    background: #eef8ff;
+    border-color: #cae8ff;
+}
+
+.tone-fine {
+    background: #f3fbef;
+    border-color: #d8f1c8;
+}
+
+.tone-rerank {
+    background: #fff4e8;
+    border-color: #ffd9b0;
+}
+
+.tone-final {
+    background: #fff1f0;
+    border-color: #ffc9c4;
+}
+
+.tone-neutral {
+    background: #f5f5f5;
+}
+
+.debug-details {
+    margin-top: 10px;
+}
+
+.debug-details summary {
+    cursor: pointer;
+    color: #555;
+    font-weight: 600;
+}
+
+.debug-json-pre {
+    margin-top: 8px;
+    padding: 10px;
+    background: #f5f5f5;
+    border-radius: 6px;
+    overflow: auto;
+    max-height: 240px;
+    white-space: pre-wrap;
+    word-break: break-word;
+}
+
+.debug-timing-list {
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.debug-timing-row {
+    display: grid;
+    grid-template-columns: 220px 1fr 90px;
+    gap: 10px;
+    align-items: center;
+}
+
+.debug-timing-label {
+    color: #444;
+}
+
+.debug-timing-bar-wrap {
+    height: 10px;
+    background: #f0f0f0;
+    border-radius: 999px;
+    overflow: hidden;
+}
+
+.debug-timing-bar {
+    height: 100%;
+    background: linear-gradient(90deg, #f39c12 0%, #e74c3c 100%);
+    border-radius: 999px;
+}
+
+.debug-timing-value {
+    text-align: right;
+    color: #666;
+    font-weight: 600;
+}
+
 .product-debug-link {
     display: inline-block;
     margin-top: 0;
@@ -687,10 +878,41 @@ footer span {
     }
     .product-grid {
-        grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));
-        gap: 15px;
         padding: 15px;
     }
+
+    .product-card {
+        flex-direction: column;
+    }
+
+    .product-main {
+        width: 100%;
+    }
+
+    .product-image-wrapper {
+        width: 100%;
+        max-width: 320px;
+    }
+
+    .product-debug {
+        width: 100%;
+        border-left: none;
+        border-top: 1px dashed #eee;
+        padding-left: 0;
+        padding-top: 12px;
+    }
+
+    .debug-stage-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .debug-timing-row {
+        grid-template-columns: 1fr;
+    }
+
+    .debug-timing-value {
+        text-align: left;
+    }
     .pagination {
         padding: 20px 15px;
@@ -699,10 +921,6 @@ footer span {
 }
 @media (max-width: 480px) {
-    .product-grid {
-        grid-template-columns: repeat(2, 1fr);
-    }
-    
     .header-left {
         gap: 15px;
     }
@@ -407,89 +407,12 @@ function displayResults(data) {
         let debugHtml = '';
         if (debug) {
-            const esScore = typeof debug.es_score === 'number' ? debug.es_score.toFixed(4) : String(debug.es_score ?? '');
-            const es_score_normalized = typeof debug.es_score_normalized === 'number'
-                ? debug.es_score_normalized.toFixed(4)
-                : (debug.es_score_normalized == null ? '' : String(debug.es_score_normalized));
-            const rerankScore = typeof debug.rerank_score === 'number'
-                ? debug.rerank_score.toFixed(4)
-                : (debug.rerank_score == null ? '' : String(debug.rerank_score));
-
-            const fusedScore = typeof debug.fused_score === 'number'
-                ? debug.fused_score.toFixed(4)
-                : (debug.fused_score == null ? '' : String(debug.fused_score));
-
-            // Build multilingual title info
-            let titleLines = '';
-            if (debug.title_multilingual && typeof debug.title_multilingual === 'object') {
-                Object.entries(debug.title_multilingual).forEach(([lang, val]) => {
-                    if (val) {
-                        titleLines += `<div class="product-debug-line">title.${escapeHtml(String(lang))}: ${escapeHtml(String(val))}</div>`;
-                    }
-                });
-            }
-
-            const resultJson = customStringify(result);
-            const rawUrl = `${API_BASE_URL}/search/es-doc/${encodeURIComponent(spuId)}?tenant_id=${encodeURIComponent(tenantId)}`;
-            const rerankInputHtml = debug.rerank_input
-                ? `
-                    <details open>
-                        <summary>Rerank input</summary>
-                        <pre style="background: #f5f5f5; padding: 10px; overflow: auto; max-height: 220px;">${escapeHtml(customStringify(debug.rerank_input))}</pre>
-                    </details>
-                `
-                : '';
-            const styleIntentHtml = debug.style_intent_sku
-                ? `
-                    <details open>
-                        <summary>Selected SKU</summary>
-                        <pre style="background: #f5f5f5; padding: 10px; overflow: auto; max-height: 220px;">${escapeHtml(customStringify(debug.style_intent_sku))}</pre>
-                    </details>
-                `
-                : '';
-            const matchedQueriesHtml = debug.matched_queries
-                ? `
-                    <details open>
-                        <summary>matched_queries</summary>
-                        <pre style="background: #f5f5f5; padding: 10px; overflow: auto; max-height: 220px;">${escapeHtml(customStringify(debug.matched_queries))}</pre>
-                    </details>
-                `
-                : '';
-
-            debugHtml = `
-                <div class="product-debug">
-                    <div class="product-debug-title">Ranking Debug</div>
-                    <div class="product-debug-line">spu_id: ${escapeHtml(String(spuId || ''))}</div>
-                    <div class="product-debug-line">Position before rerank: ${escapeHtml(String(debug.initial_rank ?? ''))}</div>
-                    <div class="product-debug-line">Position after rerank: ${escapeHtml(String(debug.final_rank ?? ''))}</div>
-                    <div class="product-debug-line">ES score: ${esScore}</div>
-                    <div class="product-debug-line">ES normalized: ${es_score_normalized}</div>
-                    <div class="product-debug-line">Rerank score: ${rerankScore}</div>
-                    <div class="product-debug-line">rerank_factor: ${escapeHtml(String(debug.rerank_factor ?? ''))}</div>
-                    <div class="product-debug-line">text_score: ${escapeHtml(String(debug.text_score ?? ''))}</div>
-                    <div class="product-debug-line">text_factor: ${escapeHtml(String(debug.text_factor ?? ''))}</div>
-                    <div class="product-debug-line">knn_score: ${escapeHtml(String(debug.knn_score ?? ''))}</div>
-                    <div class="product-debug-line">knn_factor: ${escapeHtml(String(debug.knn_factor ?? ''))}</div>
-                    <div class="product-debug-line">Fused score: ${fusedScore}</div>
-                    ${titleLines}
-                    ${rerankInputHtml}
-                    ${styleIntentHtml}
-                    ${matchedQueriesHtml}
-                    <div class="product-debug-actions">
-                        <button type="button" class="product-debug-inline-result-btn"
-                            data-action="toggle-result-inline-doc"
-                            data-result-json="${escapeAttr(resultJson)}">
-                            在结果中显示当前结果数据
-                        </button>
-                        <a class="product-debug-link" href="${rawUrl}" target="_blank" rel="noopener noreferrer">
-                            查看 ES 原始文档
-                        </a>
-                    </div>
-                    <div class="product-result-doc-panel" hidden>
-                        <pre class="product-result-doc-pre"></pre>
-                    </div>
-                </div>
-            `;
+            debugHtml = buildProductDebugHtml({
+                debug,
+                result,
+                spuId,
+                tenantId,
+            });
         }
         html += `
@@ -527,6 +450,151 @@ function displayResults(data) {
     grid.innerHTML = html;
 }
+function formatDebugNumber(value, digits = 4) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value.toFixed(digits);
+    }
+    return value == null || value === '' ? 'N/A' : String(value);
+}
+
+function renderMetricList(items) {
+    const rows = items
+        .filter((item) => item && item.value !== undefined && item.value !== null && item.value !== '')
+        .map((item) => `
+            <div class="debug-metric">
+                <div class="debug-metric-label">${escapeHtml(item.label)}</div>
+                <div class="debug-metric-value">${escapeHtml(String(item.value))}</div>
+            </div>
+        `)
+        .join('');
+    return rows ? `<div class="debug-metrics">${rows}</div>` : '';
+}
+
+function renderScorePills(items) {
+    const pills = items
+        .filter((item) => item && item.value !== undefined && item.value !== null && item.value !== '')
+        .map((item) => `
+            <div class="debug-score-pill ${item.tone || ''}">
+                <span class="debug-score-pill-label">${escapeHtml(item.label)}</span>
+                <span class="debug-score-pill-value">${escapeHtml(String(item.value))}</span>
+            </div>
+        `)
+        .join('');
+    return pills ? `<div class="debug-score-pills">${pills}</div>` : '';
+}
+
+function renderJsonDetails(title, payload, open = false) {
+    if (!payload || (typeof payload === 'object' && Object.keys(payload).length === 0)) {
+        return '';
+    }
+    return `
+        <details class="debug-details" ${open ? 'open' : ''}>
+            <summary>${escapeHtml(title)}</summary>
+            <pre class="debug-json-pre">${escapeHtml(customStringify(payload))}</pre>
+        </details>
+    `;
+}
+
+function buildProductDebugHtml({ debug, result, spuId, tenantId }) {
+    const resultJson = customStringify(result);
+    const rawUrl = `${API_BASE_URL}/search/es-doc/${encodeURIComponent(spuId)}?tenant_id=${encodeURIComponent(tenantId)}`;
+    const funnel = debug.ranking_funnel || {};
+    const esStage = funnel.es_recall || {};
+    const coarseStage = funnel.coarse_rank || {};
+    const fineStage = funnel.fine_rank || {};
+    const rerankStage = funnel.rerank || {};
+    const finalPageStage = funnel.final_page || {};
+
+    const rankSummary = renderMetricList([
+        { label: 'Initial Rank', value: debug.initial_rank ?? 'N/A' },
+        { label: 'Final Rank', value: debug.final_rank ?? 'N/A' },
+        { label: 'Rank Delta', value: (debug.initial_rank && debug.final_rank) ? String(debug.initial_rank - debug.final_rank) : 'N/A' },
+        { label: 'SPU', value: spuId || 'N/A' },
+    ]);
+
+    const stageScores = renderScorePills([
+        { label: 'ES', value: formatDebugNumber(esStage.score ?? debug.es_score), tone: 'tone-es' },
+        { label: 'ES Norm', value: formatDebugNumber(esStage.normalized_score ?? debug.es_score_normalized), tone: 'tone-neutral' },
+        { label: 'Coarse', value: formatDebugNumber(coarseStage.score ?? debug.coarse_score), tone: 'tone-coarse' },
+        { label: 'Fine', value: formatDebugNumber(fineStage.score ?? debug.fine_score), tone: 'tone-fine' },
+        { label: 'Rerank', value: formatDebugNumber(rerankStage.rerank_score ?? debug.rerank_score), tone: 'tone-rerank' },
+        { label: 'Fused', value: formatDebugNumber(rerankStage.fused_score ?? debug.fused_score), tone: 'tone-final' },
+    ]);
+
+    const stageGrid = `
+        <div class="debug-stage-grid">
+            ${buildStageCard('ES Recall', 'Matched queries and ES raw score', [
+                { label: 'rank', value: esStage.rank ?? debug.initial_rank ?? 'N/A' },
+                { label: 'es_score', value: formatDebugNumber(esStage.score ?? debug.es_score) },
+                { label: 'es_norm', value: formatDebugNumber(esStage.normalized_score ?? debug.es_score_normalized) },
+            ], renderJsonDetails('Matched Queries', esStage.matched_queries ?? debug.matched_queries, false))}
+            ${buildStageCard('Coarse Rank', 'Text + vector fusion', [
+                { label: 'rank', value: coarseStage.rank ?? 'N/A' },
+                { label: 'rank_change', value: coarseStage.rank_change ?? 'N/A' },
+                { label: 'coarse_score', value: formatDebugNumber(coarseStage.score ?? debug.coarse_score) },
+                { label: 'text_score', value: formatDebugNumber(coarseStage.text_score ?? debug.text_score) },
+                { label: 'text_source', value: formatDebugNumber(coarseStage.signals?.text_source_score ?? debug.text_source_score) },
+                { label: 'text_translation', value: formatDebugNumber(coarseStage.signals?.text_translation_score ?? debug.text_translation_score) },
+                { label: 'text_primary', value: formatDebugNumber(coarseStage.signals?.text_primary_score ?? debug.text_primary_score) },
+                { label: 'text_support', value: formatDebugNumber(coarseStage.signals?.text_support_score ?? debug.text_support_score) },
+                { label: 'knn_score', value: formatDebugNumber(coarseStage.knn_score ?? debug.knn_score) },
+                { label: 'text_knn', value: formatDebugNumber(coarseStage.signals?.text_knn_score ?? debug.text_knn_score) },
+                { label: 'image_knn', value: formatDebugNumber(coarseStage.signals?.image_knn_score ?? debug.image_knn_score) },
+                { label: 'text_factor', value: formatDebugNumber(coarseStage.text_factor ?? debug.coarse_text_factor) },
+                { label: 'knn_factor', value: formatDebugNumber(coarseStage.knn_factor ?? debug.coarse_knn_factor) },
+            ], renderJsonDetails('Coarse Signals', coarseStage.signals, false))}
+            ${buildStageCard('Fine Rank', 'Lightweight reranker output', [
+                { label: 'rank', value: fineStage.rank ?? 'N/A' },
+                { label: 'rank_change', value: fineStage.rank_change ?? 'N/A' },
+                { label: 'fine_score', value: formatDebugNumber(fineStage.score ?? debug.fine_score) },
+            ], renderJsonDetails('Fine Input', fineStage.rerank_input ?? debug.rerank_input, false))}
+            ${buildStageCard('Final Rerank', 'Heavy reranker + final fusion', [
+                { label: 'rank', value: rerankStage.rank ?? finalPageStage.rank ?? debug.final_rank ?? 'N/A' },
+                { label: 'rank_change', value: rerankStage.rank_change ?? finalPageStage.rank_change ?? 'N/A' },
+                { label: 'rerank_score', value: formatDebugNumber(rerankStage.rerank_score ?? debug.rerank_score) },
+                { label: 'text_score', value: formatDebugNumber(rerankStage.text_score ?? debug.text_score) },
+                { label: 'knn_score', value: formatDebugNumber(rerankStage.knn_score ?? debug.knn_score) },
+                { label: 'text_source', value: formatDebugNumber(rerankStage.signals?.text_source_score ?? debug.text_source_score) },
+                { label: 'text_translation', value: formatDebugNumber(rerankStage.signals?.text_translation_score ?? debug.text_translation_score) },
+                { label: 'fine_factor', value: formatDebugNumber(rerankStage.fine_factor ?? debug.fine_factor) },
+                { label: 'rerank_factor', value: formatDebugNumber(rerankStage.rerank_factor ?? debug.rerank_factor) },
+                { label: 'text_factor', value: formatDebugNumber(rerankStage.text_factor ?? debug.text_factor) },
+                { label: 'knn_factor', value: formatDebugNumber(rerankStage.knn_factor ?? debug.knn_factor) },
+                { label: 'fused_score', value: formatDebugNumber(rerankStage.fused_score ?? debug.fused_score) },
+            ], renderJsonDetails('Rerank Signals', rerankStage.signals, false))}
+        </div>
+    `;
+
+    const titlePayload = {};
+    if (debug.title_multilingual) titlePayload.title = debug.title_multilingual;
+    if (debug.brief_multilingual) titlePayload.brief = debug.brief_multilingual;
+    if (debug.vendor_multilingual) titlePayload.vendor = debug.vendor_multilingual;
+
+    return `
+        <div class="product-debug">
+            <div class="product-debug-title">Ranking Funnel</div>
+            ${rankSummary}
+            ${stageScores}
+            ${stageGrid}
+            ${renderJsonDetails('Selected SKU', debug.style_intent_sku, true)}
+            ${renderJsonDetails('Multilingual Fields', titlePayload, false)}
+            <div class="product-debug-actions">
+                <button type="button" class="product-debug-inline-result-btn"
+                    data-action="toggle-result-inline-doc"
+                    data-result-json="${escapeAttr(resultJson)}">
+                    在结果中显示当前结果数据
+                </button>
+                <a class="product-debug-link" href="${rawUrl}" target="_blank" rel="noopener noreferrer">
+                    查看 ES 原始文档
+                </a>
+            </div>
+            <div class="product-result-doc-panel" hidden>
+                <pre class="product-result-doc-pre"></pre>
+            </div>
+        </div>
+    `;
+}
+
 // Display facets as filter tags (一级分类 + 三个属性分面)
 function displayFacets(facets) {
     if (!facets || !Array.isArray(facets)) {
@@ -919,127 +987,181 @@ function formatIntentDetectionHtml(intent) {
     return block;
 }
+function buildStageCard(title, subtitle, metrics, extraHtml = '') {
+    return `
+        <div class="debug-stage-card">
+            <div class="debug-stage-title">${escapeHtml(title)}</div>
+            ${subtitle ? `<div class="debug-stage-subtitle">${escapeHtml(subtitle)}</div>` : ''}
+            ${renderMetricList(metrics)}
+            ${extraHtml}
+        </div>
+    `;
+}
+
+function renderTimingBars(stageTimings) {
+    if (!stageTimings || typeof stageTimings !== 'object') {
+        return '';
+    }
+    const orderedStages = [
+        'query_parsing',
+        'query_building',
+        'elasticsearch_search_primary',
+        'coarse_ranking',
+        'style_sku_prepare_hits',
+        'fine_ranking',
+        'reranking',
+        'elasticsearch_page_fill',
+        'result_processing',
+        'total_search',
+    ];
+    const entries = Object.entries(stageTimings)
+        .sort((a, b) => {
+            const ai = orderedStages.indexOf(a[0]);
+            const bi = orderedStages.indexOf(b[0]);
+            return (ai === -1 ? 999 : ai) - (bi === -1 ? 999 : bi);
+        });
+    const total = Number(stageTimings.total_search || 0);
+    return `
+        <div class="debug-timing-list">
+            ${entries.map(([stage, duration]) => {
+                const numeric = Number(duration) || 0;
+                const width = total > 0 ? Math.max(2, Math.round((numeric / total) * 100)) : 2;
+                return `
+                    <div class="debug-timing-row">
+                        <div class="debug-timing-label">${escapeHtml(stage)}</div>
+                        <div class="debug-timing-bar-wrap"><div class="debug-timing-bar" style="width:${width}%"></div></div>
+                        <div class="debug-timing-value">${numeric.toFixed(2)}ms</div>
+                    </div>
+                `;
+            }).join('')}
+        </div>
+    `;
+}
+
+function buildGlobalFunnelHtml(data, debugInfo) {
+    const queryAnalysis = debugInfo.query_analysis || {};
+    const searchParams = debugInfo.search_params || {};
+    const featureFlags = debugInfo.feature_flags || {};
+    const esResponse = debugInfo.es_response || {};
+    const esQueryContext = debugInfo.es_query_context || {};
+    const rankingFunnel = debugInfo.ranking_funnel || {};
+    const coarseInfo = rankingFunnel.coarse_rank || debugInfo.coarse_rank || {};
+    const fineInfo = rankingFunnel.fine_rank || debugInfo.fine_rank || {};
+    const rerankInfo = rankingFunnel.rerank || debugInfo.rerank || {};
+    const translations = queryAnalysis.translations || {};
+
+    const summaryHtml = `
+        <div class="debug-section-block">
+            <div class="debug-section-title">Query Context</div>
+            ${renderMetricList([
+                { label: 'original_query', value: queryAnalysis.original_query || 'N/A' },
+                { label: 'rewritten_query', value: queryAnalysis.rewritten_query || 'N/A' },
+                { label: 'detected_language', value: queryAnalysis.detected_language || 'N/A' },
+                { label: 'index_languages', value: (queryAnalysis.index_languages || []).join(', ') || 'N/A' },
+                { label: 'query_tokens', value: (queryAnalysis.query_tokens || []).join(', ') || 'N/A' },
+                { label: 'translation_enabled', value: featureFlags.translation_enabled ? 'enabled' : 'disabled' },
+                { label: 'embedding_enabled', value: featureFlags.embedding_enabled ? 'enabled' : 'disabled' },
+                { label: 'style_intent_active', value: featureFlags.style_intent_active ? 'yes' : 'no' },
+            ])}
+            ${Object.keys(translations).length ? renderJsonDetails('Translations', translations, true) : ''}
+            ${formatIntentDetectionHtml(queryAnalysis.intent_detection ?? queryAnalysis.style_intent_profile)}
+        </div>
+    `;
+
+    const funnelHtml = `
+        <div class="debug-section-block">
+            <div class="debug-section-title">Ranking Funnel</div>
+            <div class="debug-stage-grid">
+                ${buildStageCard('ES Recall', 'First-pass retrieval', [
+                    { label: 'fetch_from', value: searchParams.es_fetch_from ?? 0 },
+                    { label: 'fetch_size', value: searchParams.es_fetch_size ?? 'N/A' },
+                    { label: 'total_hits', value: esResponse.total_hits ?? 'N/A' },
+                    { label: 'es_took_ms', value: esResponse.took_ms ?? 'N/A' },
+                    { label: 'include_named_queries_score', value: esQueryContext.include_named_queries_score ? 'yes' : 'no' },
+                ])}
+                ${buildStageCard('Coarse Rank', 'Lexical + vector fusion only', [
+                    { label: 'docs_in', value: coarseInfo.docs_in ?? searchParams.es_fetch_size ?? 'N/A' },
+                    { label: 'docs_out', value: coarseInfo.docs_out ?? 'N/A' },
+                    { label: 'formula', value: 'text x knn' },
+                ], coarseInfo.fusion ? renderJsonDetails('Coarse Fusion', coarseInfo.fusion, false) : '')}
+                ${buildStageCard('Fine Rank', 'Lightweight reranker', [
+                    { label: 'service_url', value: fineInfo.service_url || 'N/A' },
+                    { label: 'docs_in', value: fineInfo.docs_in ?? 'N/A' },
+                    { label: 'docs_out', value: fineInfo.docs_out ?? fineInfo.top_n ?? 'N/A' },
+                    { label: 'top_n', value: fineInfo.top_n ?? 'N/A' },
+                    { label: 'backend', value: fineInfo.backend || 'N/A' },
+                    { label: 'model', value: fineInfo.model || fineInfo.backend_model_name || 'N/A' },
+                    { label: 'query_template', value: fineInfo.query_template || 'N/A' },
+                ], fineInfo.meta ? renderJsonDetails('Fine Meta', fineInfo.meta, false) : '')}
+                ${buildStageCard('Final Rerank', 'Heavy reranker + final fusion', [
+                    { label: 'service_url', value: rerankInfo.service_url || 'N/A' },
+                    { label: 'docs_in', value: rerankInfo.docs_in ?? 'N/A' },
+                    { label: 'docs_out', value: rerankInfo.docs_out ?? 'N/A' },
+                    { label: 'top_n', value: rerankInfo.top_n ?? 'N/A' },
+                    { label: 'backend', value: rerankInfo.backend || 'N/A' },
+                    { label: 'model', value: rerankInfo.model || rerankInfo.backend_model_name || 'N/A' },
+                    { label: 'query_template', value: rerankInfo.query_template || 'N/A' },
+                ], `${rerankInfo.fusion ? renderJsonDetails('Final Fusion', rerankInfo.fusion, false) : ''}${rerankInfo.meta ? renderJsonDetails('Rerank Meta', rerankInfo.meta, false) : ''}`)}
+                ${buildStageCard('Page Return', 'Final slice returned to UI', [
+                    { label: 'from', value: searchParams.from_ ?? 0 },
+                    { label: 'size', value: searchParams.size ?? 'N/A' },
+                    { label: 'returned', value: (data.results || []).length },
+                    { label: 'max_score', value: formatDebugNumber(esResponse.max_score, 3) },
+                ])}
+            </div>
+        </div>
+    `;
+
+    const timingHtml = `
+        <div class="debug-section-block">
+            <div class="debug-section-title">Timing Breakdown</div>
+            ${renderTimingBars(debugInfo.stage_timings)}
+        </div>
+    `;
+
+    const rawPayloadHtml = `
+        <div class="debug-section-block">
+            <div class="debug-section-title">Raw Payloads</div>
+            ${renderJsonDetails('ES Query DSL', debugInfo.es_query, false)}
+            ${renderJsonDetails('ES Query Context', debugInfo.es_query_context, false)}
+            ${renderJsonDetails('Search Params', debugInfo.search_params, false)}
+        </div>
+    `;
+
+    return `
+        <div class="debug-panel">
+            ${summaryHtml}
+            ${funnelHtml}
+            ${timingHtml}
+            ${rawPayloadHtml}
+        </div>
+    `;
+}
+
 // Display debug info
 function displayDebugInfo(data) {
     const debugInfoDiv = document.getElementById('debugInfo');
-    
+
     if (!state.debug || !data.debug_info) {
-        // If debug mode is off or no debug info, show basic query info
         if (data.query_info) {
-            let html = '<div style="padding: 10px;">';
-            html += `<div><strong>original_query:</strong> ${escapeHtml(data.query_info.original_query || 'N/A')}</div>`;
-            html += `<div><strong>detected_language:</strong> ${escapeHtml(data.query_info.detected_language || 'N/A')}</div>`;
-            html += '</div>';
-            debugInfoDiv.innerHTML = html;
+            debugInfoDiv.innerHTML = `
+                <div class="debug-panel">
+                    <div class="debug-section-block">
+                        <div class="debug-section-title">Query Context</div>
+                        ${renderMetricList([
+                            { label: 'original_query', value: data.query_info.original_query || 'N/A' },
+                            { label: 'detected_language', value: data.query_info.detected_language || 'N/A' },
+                        ])}
+                    </div>
+                </div>
+            `;
         } else {
             debugInfoDiv.innerHTML = '';
         }
         return;
     }
-    
-    // Display comprehensive debug info when debug mode is on
-    const debugInfo = data.debug_info;
-    let html = '<div style="padding: 10px; font-family: monospace; font-size: 12px;">';
-    
-    // Query Analysis
-    if (debugInfo.query_analysis) {
-        html += '<div style="margin-bottom: 15px;"><strong style="font-size: 14px;">Query Analysis:</strong>';
-        html += `<div>original_query: ${escapeHtml(debugInfo.query_analysis.original_query || 'N/A')}</div>`;
-        html += `<div>query_normalized: ${escapeHtml(debugInfo.query_analysis.query_normalized || 'N/A')}</div>`;
-        html += `<div>rewritten_query: ${escapeHtml(debugInfo.query_analysis.rewritten_query || 'N/A')}</div>`;
-        html += `<div>detected_language: ${escapeHtml(debugInfo.query_analysis.detected_language || 'N/A')}</div>`;
-        html += `<div>index_languages: ${escapeHtml((debugInfo.query_analysis.index_languages || []).join(', ') || 'N/A')}</div>`;
-        html += `<div>query_tokens: ${escapeHtml((debugInfo.query_analysis.query_tokens || []).join(', ') || 'N/A')}</div>`;
-        
-        if (debugInfo.query_analysis.translations && Object.keys(debugInfo.query_analysis.translations).length > 0) {
-            html += '<div>translations: ';
-            for (const [lang, translation] of Object.entries(debugInfo.query_analysis.translations)) {
-                if (translation) {
-                    html += `${lang}: ${escapeHtml(translation)}; `;
-                }
-            }
-            html += '</div>';
-        }
-        
-        if (debugInfo.query_analysis.boolean_ast) {
-            html += `<div>boolean_ast: ${escapeHtml(debugInfo.query_analysis.boolean_ast)}</div>`;
-        }
-        const intentPayload = debugInfo.query_analysis.intent_detection ?? debugInfo.query_analysis.style_intent_profile;
-        html += formatIntentDetectionHtml(intentPayload);
-        
-        html += '</div>';
-    }
-    
-    // Feature Flags
-    if (debugInfo.feature_flags) {
-        html += '<div style="margin-bottom: 15px;"><strong style="font-size: 14px;">Feature Flags:</strong>';
-        html += `<div>translation_enabled: ${debugInfo.feature_flags.translation_enabled ? 'enabled' : 'disabled'}</div>`;
-        html += `<div>embedding_enabled: ${debugInfo.feature_flags.embedding_enabled ? 'enabled' : 'disabled'}</div>`;
-        html += `<div>rerank_enabled: ${debugInfo.feature_flags.rerank_enabled ? 'enabled' : 'disabled'}</div>`;
-        if (debugInfo.feature_flags.style_intent_enabled !== undefined) {
-            html += `<div>style_intent_enabled: ${debugInfo.feature_flags.style_intent_enabled ? 'enabled' : 'disabled'}</div>`;
-        }
-        if (debugInfo.feature_flags.style_intent_active !== undefined) {
-            html += `<div>style_intent_active: ${debugInfo.feature_flags.style_intent_active ? 'yes' : 'no'}</div>`;
-        }
-        html += '</div>';
-    }
-    
-    // ES Response
-    if (debugInfo.es_response) {
-        html += '<div style="margin-bottom: 15px;"><strong style="font-size: 14px;">ES Response:</strong>';
-        html += `<div>took_ms: ${debugInfo.es_response.took_ms}ms</div>`;
-        html += `<div>total_hits: ${debugInfo.es_response.total_hits}</div>`;
-        html += `<div>max_score: ${debugInfo.es_response.max_score?.toFixed(3) || 0}</div>`;
-        html += `<div>es_score_normalization_factor: ${escapeHtml(String(debugInfo.es_response.es_score_normalization_factor ?? ''))}</div>`;
-        html += '</div>';
-    }
-
-    if (debugInfo.rerank) {
-        html += '<div style="margin-bottom: 15px;"><strong style="font-size: 14px;">Rerank:</strong>';
-        html += `<div>query_template: ${escapeHtml(debugInfo.rerank.query_template || 'N/A')}</div>`;
-        html += `<div>doc_template: ${escapeHtml(debugInfo.rerank.doc_template || 'N/A')}</div>`;
-        html += `<div>query_text: ${escapeHtml(debugInfo.rerank.query_text || 'N/A')}</div>`;
-        html += `<div>docs: ${escapeHtml(String(debugInfo.rerank.docs ?? ''))}</div>`;
-        html += `<div>top_n: ${escapeHtml(String(debugInfo.rerank.top_n ?? ''))}</div>`;
-        if (debugInfo.rerank.fusion) {
-            html += '<div>fusion:</div>';
-            html += `<pre style="background: #f5f5f5; padding: 10px; overflow: auto; max-height: 160px;">${escapeHtml(customStringify(debugInfo.rerank.fusion))}</pre>`;
-        }
-        html += '</div>';
-    }
-    
-    // Stage Timings
-    if (debugInfo.stage_timings) {
-        html += '<div style="margin-bottom: 15px;"><strong style="font-size: 14px;">Stage Timings:</strong>';
-        const bounds = debugInfo.stage_time_bounds_ms || {};
-        for (const [stage, duration] of Object.entries(debugInfo.stage_timings)) {
-            const b = bounds[stage];
-            if (b && b.start_unix_ms != null && b.end_unix_ms != null) {
-                html += `<div>${stage}: ${Number(duration).toFixed(2)}ms <span style="color:#666">(start ${b.start_unix_ms} → end ${b.end_unix_ms} unix ms)</span></div>`;
-            } else {
-                html += `<div>${stage}: ${Number(duration).toFixed(2)}ms</div>`;
-            }
-        }
-        html += '</div>';
-    }
-    
-    // ES Query
-    if (debugInfo.es_query) {
-        html += '<div style="margin-bottom: 15px;"><strong style="font-size: 14px;">ES Query DSL:</strong>';
-        html += `<pre style="background: #f5f5f5; padding: 10px; overflow: auto; max-height: 400px;">${escapeHtml(customStringify(debugInfo.es_query))}</pre>`;
-        html += '</div>';
-    }
-
-    if (debugInfo.es_query_context) {
-        html += '<div style="margin-bottom: 15px;"><strong style="font-size: 14px;">ES Query Context:</strong>';
-        html += `<pre style="background: #f5f5f5; padding: 10px; overflow: auto; max-height: 240px;">${escapeHtml(customStringify(debugInfo.es_query_context))}</pre>`;
-        html += '</div>';
-    }
-    
-    html += '</div>';
-    debugInfoDiv.innerHTML = html;
+    debugInfoDiv.innerHTML = buildGlobalFunnelHtml(data, data.debug_info);
 }
 // Custom JSON stringify that compresses numeric arrays (like embeddings) to single line
@@ -1070,4 +1192,3 @@ function formatDate(dateStr) {
         return dateStr;
     }
 }
-
@@ -57,7 +57,7 @@ class HttpRerankProvider:
             return None, None
-def create_rerank_provider() -> HttpRerankProvider:
+def create_rerank_provider(service_profile: Optional[str] = None) -> HttpRerankProvider:
     """Create rerank provider from services config."""
     cfg = get_rerank_config()
     provider = (cfg.provider or "http").strip().lower()
@@ -65,5 +65,5 @@ def create_rerank_provider() -&gt; HttpRerankProvider:
     if provider != "http":
         raise ValueError(f"Unsupported rerank provider: {provider}")
-    url = get_rerank_service_url()
+    url = get_rerank_service_url(profile=service_profile)
     return HttpRerankProvider(service_url=url)
@@ -2,6 +2,7 @@
 from .language_detector import LanguageDetector
 from .query_rewriter import QueryRewriter, QueryNormalizer
+from .keyword_extractor import KEYWORDS_QUERY_BASE_KEY
 from .query_parser import QueryParser, ParsedQuery
 __all__ = [
@@ -10,4 +11,5 @@ __all__ = [
     'QueryNormalizer',
     'QueryParser',
     'ParsedQuery',
+    'KEYWORDS_QUERY_BASE_KEY',
 ]
@@ -0,0 +1,86 @@
+"""
+HanLP-based noun keyword string for lexical constraints (token POS starts with N, length >= 2).
+
+``ParsedQuery.keywords_queries`` uses the same key layout as text variants:
+``KEYWORDS_QUERY_BASE_KEY`` for the rewritten source query, and ISO-like language
+codes for each ``ParsedQuery.translations`` entry (non-empty extractions only).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+import hanlp  # type: ignore
+
+# Aligns with ``rewritten_query`` / ES ``base_query`` (not a language code).
+KEYWORDS_QUERY_BASE_KEY = "base"
+
+
+class KeywordExtractor:
+    """基于 HanLP 的名词关键词提取器（与分词位置对齐，非连续名词间插入空格）。"""
+
+    def __init__(
+        self,
+        tokenizer: Optional[Any] = None,
+        *,
+        ignore_keywords: Optional[List[str]] = None,
+    ):
+        if tokenizer is not None:
+            self.tok = tokenizer
+        else:
+            self.tok = hanlp.load(hanlp.pretrained.tok.CTB9_TOK_ELECTRA_BASE_CRF)
+            self.tok.config.output_spans = True
+        self.pos_tag = hanlp.load(hanlp.pretrained.pos.CTB9_POS_ELECTRA_SMALL)
+        self.ignore_keywords = frozenset(ignore_keywords or ["玩具"])
+
+    def extract_keywords(self, query: str) -> str:
+        """
+        从查询中提取关键词（名词，长度 ≥ 2），以空格分隔非连续片段。
+        """
+        query = (query or "").strip()
+        if not query:
+            return ""
+        tok_result_with_position = self.tok(query)
+        tok_result = [x[0] for x in tok_result_with_position]
+        if not tok_result:
+            return ""
+        pos_tags = self.pos_tag(tok_result)
+        pos_tag_result = list(zip(tok_result, pos_tags))
+        keywords: List[str] = []
+        last_end_pos = 0
+        for (word, postag), (_, start_pos, end_pos) in zip(pos_tag_result, tok_result_with_position):
+            if len(word) >= 2 and str(postag).startswith("N"):
+                if word in self.ignore_keywords:
+                    continue
+                if start_pos != last_end_pos and keywords:
+                    keywords.append(" ")
+                keywords.append(word)
+                last_end_pos = end_pos
+        return "".join(keywords).strip()
+
+
+def collect_keywords_queries(
+    extractor: KeywordExtractor,
+    rewritten_query: str,
+    translations: Dict[str, str],
+) -> Dict[str, str]:
+    """
+    Build the keyword map for all lexical variants (base + translations).
+
+    Omits entries when extraction yields an empty string.
+    """
+    out: Dict[str, str] = {}
+    base_kw = extractor.extract_keywords(rewritten_query)
+    if base_kw:
+        out[KEYWORDS_QUERY_BASE_KEY] = base_kw
+    for lang, text in translations.items():
+        lang_key = str(lang or "").strip().lower()
+        if not lang_key or not (text or "").strip():
+            continue
+        kw = extractor.extract_keywords(text)
+        if kw:
+            out[lang_key] = kw
+    return out
@@ -27,6 +27,7 @@ from .product_title_exclusion import (
 from .query_rewriter import QueryRewriter, QueryNormalizer
 from .style_intent import StyleIntentDetector, StyleIntentProfile, StyleIntentRegistry
 from .tokenization import extract_token_strings, simple_tokenize_query
+from .keyword_extractor import KeywordExtractor, collect_keywords_queries
 logger = logging.getLogger(__name__)
@@ -59,7 +60,14 @@ def rerank_query_text(
 @dataclass(slots=True)
 class ParsedQuery:
-    """Container for query parser facts."""
+    """
+    Container for query parser facts.
+
+    ``keywords_queries`` parallels text variants: key ``base`` (see
+    ``keyword_extractor.KEYWORDS_QUERY_BASE_KEY``) for ``rewritten_query``,
+    and the same language codes as ``translations`` for each translated string.
+    Entries with no extracted nouns are omitted.
+    """
     original_query: str
     query_normalized: str
@@ -69,6 +77,7 @@ class ParsedQuery:
     query_vector: Optional[np.ndarray] = None
     image_query_vector: Optional[np.ndarray] = None
     query_tokens: List[str] = field(default_factory=list)
+    keywords_queries: Dict[str, str] = field(default_factory=dict)
     style_intent_profile: Optional[StyleIntentProfile] = None
     product_title_exclusion_profile: Optional[ProductTitleExclusionProfile] = None
@@ -91,6 +100,7 @@ class ParsedQuery:
             "has_query_vector": self.query_vector is not None,
             "has_image_query_vector": self.image_query_vector is not None,
             "query_tokens": self.query_tokens,
+            "keywords_queries": dict(self.keywords_queries),
             "style_intent_profile": (
                 self.style_intent_profile.to_dict() if self.style_intent_profile is not None else None
             ),
@@ -138,6 +148,7 @@ class QueryParser:
         self.language_detector = LanguageDetector()
         self.rewriter = QueryRewriter(config.query_config.rewrite_dictionary)
         self._tokenizer = tokenizer or self._build_tokenizer()
+        self._keyword_extractor = KeywordExtractor(tokenizer=self._tokenizer)
         self.style_intent_registry = StyleIntentRegistry.from_query_config(config.query_config)
         self.style_intent_detector = StyleIntentDetector(
             self.style_intent_registry,
@@ -523,6 +534,16 @@ class QueryParser:
             if translations and context:
                 context.store_intermediate_result("translations", translations)
+        keywords_queries: Dict[str, str] = {}
+        try:
+            keywords_queries = collect_keywords_queries(
+                self._keyword_extractor,
+                query_text,
+                translations,
+            )
+        except Exception as e:
+            log_info(f"Keyword extraction failed | Error: {e}")
+
         # Build result
         base_result = ParsedQuery(
             original_query=query,
@@ -533,6 +554,7 @@ class QueryParser:
             query_vector=query_vector,
             image_query_vector=image_query_vector,
             query_tokens=query_tokens,
+            keywords_queries=keywords_queries,
         )
         style_intent_profile = self.style_intent_detector.detect(base_result)
         product_title_exclusion_profile = self.product_title_exclusion_detector.detect(base_result)
@@ -555,6 +577,7 @@ class QueryParser:
             query_vector=query_vector,
             image_query_vector=image_query_vector,
             query_tokens=query_tokens,
+            keywords_queries=keywords_queries,
             style_intent_profile=style_intent_profile,
             product_title_exclusion_profile=product_title_exclusion_profile,
         )
@@ -71,7 +71,7 @@ Reranker 服务提供统一的 `/rerank` API，支持可插拔后端（BGE、Jin
 - `qwen3_transformers_packed` -> `.venv-reranker-transformers-packed`
 - `qwen3_gguf` -> `.venv-reranker-gguf`
 - `qwen3_gguf_06b` -> `.venv-reranker-gguf-06b`
-- `bge` -> `.venv-reranker-bge`
+- `bge` -> `.venv-reranker`
 - `dashscope_rerank` -> `.venv-reranker-dashscope`
@@ -2,19 +2,29 @@
 from __future__ import annotations
+import os
+
 from config.loader import get_app_config
 class RerankerConfig(object):
     def __init__(self) -> None:
         app_config = get_app_config()
-        runtime = app_config.runtime
         service = app_config.services.rerank
-        backend = service.get_backend_config()
+        instance_name = str(os.getenv("RERANK_INSTANCE") or service.default_instance).strip() or service.default_instance
+        instance = service.get_instance(instance_name)
+        backend = service.get_backend_config(instance_name)
         request = service.request
-        self.HOST = runtime.reranker_host
-        self.PORT = runtime.reranker_port
+        self.INSTANCE = instance_name
+        self.HOST = str(os.getenv("RERANKER_HOST") or instance.host)
+        self.PORT = int(os.getenv("RERANKER_PORT") or instance.port)
+        self.BACKEND = str(os.getenv("RERANK_BACKEND") or instance.backend)
+        self.RUNTIME_DIR = str(
+            os.getenv("RERANKER_RUNTIME_DIR")
+            or instance.runtime_dir
+            or f"./.runtime/reranker/{instance_name}"
+        )
         self.MODEL_NAME = str(backend.get("model_name") or "Qwen/Qwen3-Reranker-0.6B")
         self.DEVICE = backend.get("device")
@@ -6,7 +6,7 @@ POST /rerank
 Request: { "query": "...", "docs": ["doc1", "doc2", ...], "normalize": optional bool }
 Response: { "scores": [float], "meta": {...} }
-Backend selected via config: services.rerank.backend
+Backend selected via config: services.rerank.instances.<name>.backend
 (bge | jina_reranker_v3 | qwen3_vllm | qwen3_vllm_score | qwen3_transformers | qwen3_transformers_packed | qwen3_gguf | qwen3_gguf_06b | dashscope_rerank), env RERANK_BACKEND.
 """
@@ -76,14 +76,15 @@ class RerankResponse(BaseModel):
 @app.on_event("startup")
 def load_model() -> None:
     global _reranker, _backend_name
-    logger.info("Starting reranker service on port %s", CONFIG.PORT)
+    logger.info("Starting reranker service | instance=%s port=%s", CONFIG.INSTANCE, CONFIG.PORT)
     try:
-        backend_name, backend_cfg = get_rerank_backend_config()
+        backend_name, backend_cfg = get_rerank_backend_config(CONFIG.INSTANCE)
         _backend_name = backend_name
         _reranker = get_rerank_backend(backend_name, backend_cfg)
         model_info = getattr(_reranker, "_model_name", None) or backend_cfg.get("model_name", backend_name)
         logger.info(
-            "Reranker ready | backend=%s model=%s",
+            "Reranker ready | instance=%s backend=%s model=%s",
+            CONFIG.INSTANCE,
             _backend_name,
             model_info,
         )
@@ -101,6 +102,7 @@ def health() -&gt; Dict[str, Any]:
         ).get("model_name", _backend_name)
     payload: Dict[str, Any] = {
         "status": "ok" if _reranker is not None else "unavailable",
+        "instance": CONFIG.INSTANCE,
         "model_loaded": _reranker is not None,
         "model": model_info,
         "backend": _backend_name,
@@ -0,0 +1,554 @@
+#!/usr/bin/env python3
+"""
+Offline experiment: English query bucketing (intersection / boost / drop).
+
+Scheme A: spaCy noun_chunks + head + lemma + rule buckets
+Scheme B: spaCy NP candidates + KeyBERT rerank → intersection vs boost
+Scheme C: YAKE + spaCy noun/POS filter
+
+Run (after deps): python scripts/experiments/english_query_bucketing_demo.py
+Optional: pip install -r scripts/experiments/requirements_query_bucketing_experiments.txt
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple
+
+
+# --- shared -----------------------------------------------------------------
+
+_POSSESSIVE_RE = re.compile(r"(['’]s)\b", re.IGNORECASE)
+
+
+def normalize_query(s: str) -> str:
+    s = (s or "").strip()
+    s = _POSSESSIVE_RE.sub("", s)
+    return s
+
+
+@dataclass
+class BucketResult:
+    intersection_terms: List[str] = field(default_factory=list)
+    boost_terms: List[str] = field(default_factory=list)
+    drop_terms: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "intersection_terms": self.intersection_terms,
+            "boost_terms": self.boost_terms,
+            "drop_terms": self.drop_terms,
+        }
+
+
+def _dedupe_preserve(seq: Sequence[str]) -> List[str]:
+    seen: Set[str] = set()
+    out: List[str] = []
+    for x in seq:
+        k = x.strip().lower()
+        if not k or k in seen:
+            continue
+        seen.add(k)
+        out.append(x.strip())
+    return out
+
+
+# --- Scheme A: spaCy + rules -------------------------------------------------
+
+WEAK_BOOST_ADJS = frozenset(
+    {
+        "best",
+        "good",
+        "great",
+        "new",
+        "free",
+        "cheap",
+        "top",
+        "fine",
+        "real",
+    }
+)
+
+FUNCTIONAL_DEP = frozenset(
+    {
+        "det",
+        "aux",
+        "auxpass",
+        "prep",
+        "mark",
+        "expl",
+        "cc",
+        "punct",
+        "case",
+    }
+)
+
+# Second pobj under list-like INTJ roots often encodes audience/size (boost, not must-match).
+_DEMOGRAPHIC_NOUNS = frozenset(
+    {
+        "women",
+        "woman",
+        "men",
+        "man",
+        "kids",
+        "kid",
+        "boys",
+        "boy",
+        "girls",
+        "girl",
+        "baby",
+        "babies",
+        "toddler",
+        "adult",
+        "adults",
+    }
+)
+
+
+def _lemma_lower(t) -> str:
+    return ((t.lemma_ or t.text) or "").lower().strip()
+
+
+def _surface_lower(t) -> str:
+    """Lowercased surface form (keeps plural 'headphones' vs lemma 'headphone')."""
+    return (t.text or "").lower().strip()
+
+
+_PRICE_PREP_LEMMAS = frozenset({"under", "over", "below", "above", "within", "between", "near"})
+
+
+def bucket_scheme_a_spacy(query: str, nlp) -> BucketResult:
+    """
+    Dependency-first bucketing: noun_chunks alone mis-parse verbal queries like
+    "noise cancelling headphones" (ROOT verb). Prefer dobj / ROOT product nouns,
+    purpose PP (for …), and brand INTJ/PROPN.
+    """
+    import spacy  # noqa: F401
+
+    # Do not strip possessives ('s) before spaCy: it changes the parse tree
+    # (e.g. "women's running shoes size 8" vs "women running shoes size 8").
+    text = (query or "").strip()
+    doc = nlp(text)
+    intersection: Set[str] = set()
+    boost: Set[str] = set()
+    drop: Set[str] = set()
+
+    stops = nlp.Defaults.stop_words | WEAK_BOOST_ADJS
+
+    def mark_drop(t) -> None:
+        if not t.is_space and not t.is_punct:
+            drop.add(t.text.lower())
+
+    # --- Drops: function words / question words ---
+    for token in doc:
+        if token.is_space or token.is_punct:
+            continue
+        lem = _lemma_lower(token)
+        if token.pos_ in ("DET", "PRON", "AUX", "ADP", "PART", "SCONJ", "CCONJ"):
+            mark_drop(token)
+            continue
+        if token.dep_ in FUNCTIONAL_DEP:
+            mark_drop(token)
+            continue
+        if token.pos_ == "ADV" and lem in {"where", "how", "when", "why", "what", "which"}:
+            mark_drop(token)
+            continue
+        if token.text.lower() in ("'s", "’s"):
+            mark_drop(token)
+            continue
+        if lem in stops and token.pos_ != "PROPN":
+            mark_drop(token)
+
+    pobj_heads_to_demote: Set[int] = set()
+
+    # Purpose / context: "for airplane travel" → boost phrase; demote bare head from intersection
+    for token in doc:
+        if token.dep_ == "prep" and token.text.lower() == "for":
+            for c in token.children:
+                if c.dep_ == "pobj" and c.pos_ in ("NOUN", "PROPN"):
+                    span = doc[c.left_edge.i : c.right_edge.i + 1]
+                    phrase = span.text.strip().lower()
+                    if phrase:
+                        boost.add(phrase)
+                    pobj_heads_to_demote.add(c.i)
+
+    # Price / range: "under 500 dollars" → boost only
+    for token in doc:
+        if token.dep_ != "prep" or _lemma_lower(token) not in _PRICE_PREP_LEMMAS:
+            continue
+        for c in token.children:
+            if c.dep_ == "pobj" and c.pos_ in ("NOUN", "PROPN"):
+                span = doc[c.left_edge.i : c.right_edge.i + 1]
+                phrase = span.text.strip().lower()
+                if phrase:
+                    boost.add(phrase)
+                pobj_heads_to_demote.add(c.i)
+
+    # Direct object product nouns (handles "noise cancelling … headphones")
+    for token in doc:
+        if token.dep_ == "dobj" and token.pos_ in ("NOUN", "PROPN"):
+            if token.i in pobj_heads_to_demote:
+                continue
+            intersection.add(_surface_lower(token))
+
+    # Copular questions / definitions: "what is the best smartphone …"
+    for token in doc:
+        if token.dep_ != "nsubj" or token.pos_ not in ("NOUN", "PROPN"):
+            continue
+        h = token.head
+        if h.pos_ == "AUX" and h.dep_ == "ROOT":
+            intersection.add(_surface_lower(token))
+
+    # Verbal ROOT: modifiers left of dobj → boost phrase (e.g. "noise cancelling")
+    roots = [t for t in doc if t.dep_ == "ROOT"]
+    if roots and roots[0].pos_ == "VERB":
+        root_v = roots[0]
+        for t in doc:
+            if t.dep_ != "dobj" or t.pos_ not in ("NOUN", "PROPN"):
+                continue
+            if t.i in pobj_heads_to_demote:
+                continue
+            parts: List[str] = []
+            for x in doc[: t.i]:
+                if x.is_punct or x.is_space:
+                    continue
+                if x.pos_ in ("DET", "ADP", "PRON"):
+                    continue
+                xl = _lemma_lower(x)
+                if xl in stops:
+                    continue
+                parts.append(x.text.lower())
+            if len(parts) >= 1:
+                boost.add(" ".join(parts))
+
+    # Brand / query lead: INTJ/PROPN ROOT (e.g. Nike …)
+    for token in doc:
+        if token.dep_ == "ROOT" and token.pos_ in ("INTJ", "PROPN"):
+            intersection.add(_surface_lower(token))
+        if token.pos_ == "PROPN":
+            intersection.add(_surface_lower(token))
+
+    _DIMENSION_ROOTS = frozenset({"size", "width", "length", "height", "weight"})
+
+    # "women's running shoes size 8" → shoes ∩, "size 8" boost (not size alone)
+    for token in doc:
+        if token.dep_ != "ROOT" or token.pos_ != "NOUN":
+            continue
+        if _lemma_lower(token) not in _DIMENSION_ROOTS:
+            continue
+        for c in token.children:
+            if c.dep_ == "nsubj" and c.pos_ in ("NOUN", "PROPN"):
+                intersection.add(_surface_lower(c))
+                for ch in c.children:
+                    if ch.dep_ == "compound" and ch.pos_ in ("NOUN", "VERB", "ADJ"):
+                        boost.add(_surface_lower(ch))
+                # Only the dimension head + numbers (not full subtree: left_edge/right_edge is huge)
+                dim_parts = [token.text.lower()]
+                for ch in token.children:
+                    if ch.dep_ == "nummod":
+                        dim_parts.append(ch.text.lower())
+                boost.add(" ".join(dim_parts))
+
+    # ROOT noun product (e.g. "plastic toy car")
+    for token in doc:
+        if token.dep_ == "ROOT" and token.pos_ in ("NOUN", "PROPN"):
+            if _lemma_lower(token) in _DIMENSION_ROOTS and any(
+                c.dep_ == "nsubj" and c.pos_ in ("NOUN", "PROPN") for c in token.children
+            ):
+                continue
+            intersection.add(_surface_lower(token))
+            for c in token.children:
+                if c.dep_ == "compound" and c.pos_ == "NOUN":
+                    boost.add(c.text.lower())
+            if token.i - token.left_edge.i >= 1:
+                comps = [x.text.lower() for x in doc[token.left_edge.i : token.i] if x.dep_ == "compound"]
+                if len(comps) >= 2:
+                    boost.add(" ".join(comps))
+
+    # List-like INTJ head with multiple pobj: first pobj = product head, rest often demographic
+    for token in doc:
+        if token.dep_ != "ROOT" or token.pos_ not in ("INTJ", "VERB", "NOUN"):
+            continue
+        pobjs = sorted(
+            [c for c in token.children if c.dep_ == "pobj" and c.pos_ in ("NOUN", "PROPN")],
+            key=lambda x: x.i,
+        )
+        if len(pobjs) >= 2 and token.pos_ == "INTJ":
+            intersection.add(_surface_lower(pobjs[0]))
+            for extra in pobjs[1:]:
+                if _lemma_lower(extra) in _DEMOGRAPHIC_NOUNS:
+                    boost.add(_surface_lower(extra))
+                else:
+                    intersection.add(_surface_lower(extra))
+        elif len(pobjs) == 1 and token.pos_ == "INTJ":
+            intersection.add(_surface_lower(pobjs[0]))
+
+    # amod under pobj (running → shoes)
+    for token in doc:
+        if token.dep_ == "amod" and token.head.pos_ in ("NOUN", "PROPN"):
+            if token.pos_ == "VERB":
+                boost.add(_surface_lower(token))
+            elif token.pos_ == "ADJ":
+                boost.add(_lemma_lower(token))
+
+    # Genitive possessor (women's shoes → women boost)
+    for token in doc:
+        if token.dep_ == "poss" and token.head.pos_ in ("NOUN", "PROPN"):
+            boost.add(_surface_lower(token))
+
+    # noun_chunks fallback when no dobj/ROOT intersection yet
+    if not intersection:
+        for chunk in doc.noun_chunks:
+            head = chunk.root
+            if head.pos_ not in ("NOUN", "PROPN"):
+                continue
+            # Price / range: "under 500 dollars" → boost, not a product head
+            if head.dep_ == "pobj" and head.head.dep_ == "prep":
+                prep = head.head
+                if _lemma_lower(prep) in _PRICE_PREP_LEMMAS:
+                    boost.add(chunk.text.strip().lower())
+                    continue
+            hl = _surface_lower(head)
+            if hl:
+                intersection.add(hl)
+            for t in chunk:
+                if t == head or t.pos_ != "PROPN":
+                    continue
+                intersection.add(_surface_lower(t))
+            for t in chunk:
+                if t == head:
+                    continue
+                if t.pos_ == "ADJ" or (t.pos_ == "NOUN" and t.dep_ == "compound"):
+                    boost.add(_lemma_lower(t))
+
+    # Remove demoted pobj heads from intersection (purpose / price clause)
+    for i in pobj_heads_to_demote:
+        t = doc[i]
+        intersection.discard(_lemma_lower(t))
+        intersection.discard(_surface_lower(t))
+
+    boost -= intersection
+    boost = {b for b in boost if b.lower() not in stops and b.strip()}
+
+    return BucketResult(
+        intersection_terms=_dedupe_preserve(sorted(intersection)),
+        boost_terms=_dedupe_preserve(sorted(boost)),
+        drop_terms=_dedupe_preserve(sorted(drop)),
+    )
+
+
+# --- Scheme B: spaCy candidates + KeyBERT -----------------------------------
+
+def _spacy_np_candidates(doc) -> List[str]:
+    phrases: List[str] = []
+    for chunk in doc.noun_chunks:
+        t = chunk.text.strip()
+        if len(t) < 2:
+            continue
+        root = chunk.root
+        if root.pos_ not in ("NOUN", "PROPN"):
+            continue
+        phrases.append(t)
+    return phrases
+
+
+def bucket_scheme_b_keybert(query: str, nlp, kw_model) -> BucketResult:
+    text = (query or "").strip()
+    doc = nlp(text)
+    candidates = _spacy_np_candidates(doc)
+    if not candidates:
+        candidates = [text]
+
+    # KeyBERT API: candidate_keywords=... (sentence-transformers backend)
+    try:
+        keywords = kw_model.extract_keywords(
+            text,
+            candidates=candidates,
+            top_n=min(8, max(4, len(candidates) + 2)),
+        )
+    except TypeError:
+        keywords = kw_model.extract_keywords(
+            text,
+            candidate_keywords=candidates,
+            top_n=min(8, max(4, len(candidates) + 2)),
+        )
+    ranked = [k[0].lower().strip() for k in (keywords or []) if k and k[0].strip()]
+
+    intersection: List[str] = []
+    boost: List[str] = []
+    if ranked:
+        intersection.append(ranked[0])
+        if len(ranked) > 1:
+            boost.extend(ranked[1:])
+    # Add remaining spaCy heads not in lists
+    heads: List[str] = []
+    for ch in doc.noun_chunks:
+        h = ch.root
+        if h.pos_ in ("NOUN", "PROPN"):
+            heads.append(_surface_lower(h))
+    for h in heads:
+        if h and h not in intersection and h not in boost:
+            boost.append(h)
+    if not intersection and heads:
+        intersection.append(heads[0])
+        boost = [x for x in boost if x != heads[0]]
+
+    drop_tokens: Set[str] = set()
+    stops = nlp.Defaults.stop_words | WEAK_BOOST_ADJS
+    for token in doc:
+        if token.is_punct:
+            continue
+        lem = (token.lemma_ or token.text).lower()
+        if token.pos_ in ("DET", "ADP", "PART", "PRON", "AUX") or lem in stops:
+            drop_tokens.add(token.text.lower())
+
+    return BucketResult(
+        intersection_terms=_dedupe_preserve(intersection),
+        boost_terms=_dedupe_preserve(boost),
+        drop_terms=sorted(drop_tokens),
+    )
+
+
+# --- Scheme C: YAKE + noun filter --------------------------------------------
+
+def bucket_scheme_c_yake(query: str, nlp, yake_extractor) -> BucketResult:
+    text = (query or "").strip()
+    doc = nlp(text)
+
+    kws = yake_extractor.extract_keywords(text)  # List[Tuple[str, float]] newest yake API may differ
+
+    scored: List[Tuple[str, float]] = []
+    if kws and isinstance(kws[0], (list, tuple)) and len(kws[0]) >= 2:
+        scored = [(str(a).strip(), float(b)) for a, b in kws]
+    else:
+        # older yake returns list of tuples (kw, score)
+        scored = [(str(x[0]).strip(), float(x[1])) for x in kws]
+
+    boost: List[str] = []
+    intersection: List[str] = []
+    for phrase, _score in sorted(scored, key=lambda x: x[1]):  # lower score = more important in YAKE
+        phrase = phrase.lower().strip()
+        if not phrase or len(phrase) < 2:
+            continue
+        sub = nlp(phrase)
+        keep = False
+        head_noun = False
+        for t in sub:
+            if t.is_punct or t.is_space:
+                continue
+            if t.pos_ in ("NOUN", "PROPN"):
+                keep = True
+                if t.dep_ == "ROOT" or t == sub[-1]:
+                    head_noun = True
+        if not keep:
+            continue
+        # top 1–2 important → intersection (very small)
+        if len(intersection) < 2 and head_noun and len(phrase.split()) <= 2:
+            intersection.append(phrase)
+        else:
+            boost.append(phrase)
+
+    drop: Set[str] = set()
+    stops = nlp.Defaults.stop_words | WEAK_BOOST_ADJS
+    for token in doc:
+        if token.is_punct:
+            continue
+        lem = (token.lemma_ or token.text).lower()
+        if token.pos_ in ("DET", "ADP", "PART", "PRON", "AUX") or lem in stops:
+            drop.add(token.text.lower())
+
+    return BucketResult(
+        intersection_terms=_dedupe_preserve(intersection),
+        boost_terms=_dedupe_preserve(boost),
+        drop_terms=sorted(drop),
+    )
+
+
+# --- CLI ---------------------------------------------------------------------
+
+DEFAULT_QUERIES = [
+    "best noise cancelling headphones for airplane travel",
+    "nike running shoes women",
+    "plastic toy car",
+    "what is the best smartphone under 500 dollars",
+    "women's running shoes size 8",
+]
+
+
+def _load_spacy():
+    import spacy
+
+    try:
+        return spacy.load("en_core_web_sm")
+    except OSError:
+        print(
+            "Missing model: run: python -m spacy download en_core_web_sm",
+            file=sys.stderr,
+        )
+        raise
+
+
+def _load_keybert():
+    from keybert import KeyBERT
+
+    # small & fast for demo; swap for larger if needed
+    return KeyBERT(model="paraphrase-MiniLM-L6-v2")
+
+
+def _load_yake():
+    import yake
+
+    return yake.KeywordExtractor(
+        lan="en",
+        n=3,
+        dedupLim=0.9,
+        top=20,
+        features=None,
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="English query bucketing experiments")
+    parser.add_argument(
+        "--queries",
+        nargs="*",
+        default=DEFAULT_QUERIES,
+        help="Queries to run (default: built-in examples)",
+    )
+    parser.add_argument(
+        "--scheme",
+        choices=("a", "b", "c", "all"),
+        default="all",
+    )
+    args = parser.parse_args()
+
+    nlp = _load_spacy()
+    kb = None
+    yk = None
+    if args.scheme in ("b", "all"):
+        kb = _load_keybert()
+    if args.scheme in ("c", "all"):
+        yk = _load_yake()
+
+    for q in args.queries:
+        print("=" * 72)
+        print("QUERY:", q)
+        print("-" * 72)
+        if args.scheme in ("a", "all"):
+            ra = bucket_scheme_a_spacy(q, nlp)
+            print("A  spaCy+rules:", json.dumps(ra.to_dict(), ensure_ascii=False))
+        if args.scheme in ("b", "all") and kb is not None:
+            rb = bucket_scheme_b_keybert(q, nlp, kb)
+            print("B  spaCy+KeyBERT:", json.dumps(rb.to_dict(), ensure_ascii=False))
+        if args.scheme in ("c", "all") and yk is not None:
+            rc = bucket_scheme_c_yake(q, nlp, yk)
+            print("C  YAKE+noun filter:", json.dumps(rc.to_dict(), ensure_ascii=False))
+        print()
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,6 @@
+# Optional: English query bucketing experiments
+# After install: python -m spacy download en_core_web_sm
+spacy>=3.7.0
+keybert>=0.8.0
+sentence-transformers>=2.2.0
+yake>=0.4.8
@@ -45,7 +45,7 @@ reranker_backend_venv_dir() {
     qwen3_gguf_06b) printf '%s/.venv-reranker-gguf-06b\n' "${project_root}" ;;
     qwen3_transformers) printf '%s/.venv-reranker-transformers\n' "${project_root}" ;;
     qwen3_transformers_packed) printf '%s/.venv-reranker-transformers-packed\n' "${project_root}" ;;
-    bge) printf '%s/.venv-reranker-bge\n' "${project_root}" ;;
+    bge) printf '%s/.venv-reranker\n' "${project_root}" ;;
     dashscope_rerank) printf '%s/.venv-reranker-dashscope\n' "${project_root}" ;;
     *) printf '%s/.venv-reranker-%s\n' "${project_root}" "${backend}" ;;
   esac
@@ -16,14 +16,45 @@ mkdir -p &quot;${LOG_DIR}&quot;
 source "${PROJECT_ROOT}/scripts/lib/load_env.sh"
 CORE_SERVICES=("backend" "indexer" "frontend")
-OPTIONAL_SERVICES=("tei" "cnclip" "embedding" "embedding-image" "translator" "reranker")
+OPTIONAL_SERVICES=("tei" "cnclip" "embedding" "embedding-image" "translator" "reranker" "reranker-fine")
 FULL_SERVICES=("${OPTIONAL_SERVICES[@]}" "${CORE_SERVICES[@]}")
-STOP_ORDER_SERVICES=("frontend" "indexer" "backend" "reranker" "translator" "embedding-image" "embedding" "cnclip" "tei")
+STOP_ORDER_SERVICES=("frontend" "indexer" "backend" "reranker-fine" "reranker" "translator" "embedding-image" "embedding" "cnclip" "tei")
 all_services() {
   echo "${FULL_SERVICES[@]}"
 }
+config_python_bin() {
+  if [ -x "${PROJECT_ROOT}/.venv/bin/python" ]; then
+    echo "${PROJECT_ROOT}/.venv/bin/python"
+  else
+    echo "${PYTHON:-python3}"
+  fi
+}
+
+reranker_instance_for_service() {
+  local service="$1"
+  case "${service}" in
+    reranker) echo "default" ;;
+    reranker-fine) echo "fine" ;;
+    *) echo "" ;;
+  esac
+}
+
+get_reranker_instance_port() {
+  local instance="$1"
+  local pybin
+  pybin="$(config_python_bin)"
+  RERANK_INSTANCE="${instance}" PYTHONPATH="${PROJECT_ROOT}${PYTHONPATH:+:${PYTHONPATH}}" "${pybin}" - <<'PY'
+from config.loader import get_app_config
+import os
+
+cfg = get_app_config().services.rerank
+name = (os.getenv("RERANK_INSTANCE") or cfg.default_instance).strip() or cfg.default_instance
+print(cfg.get_instance(name).port)
+PY
+}
+
 get_port() {
   local service="$1"
   case "${service}" in
@@ -33,7 +64,20 @@ get_port() {
     embedding) echo "${EMBEDDING_TEXT_PORT:-6005}" ;;
     embedding-image) echo "${EMBEDDING_IMAGE_PORT:-6008}" ;;
     translator) echo "${TRANSLATION_PORT:-6006}" ;;
-    reranker) echo "${RERANKER_PORT:-6007}" ;;
+    reranker)
+      if [ -n "${RERANKER_PORT:-}" ]; then
+        echo "${RERANKER_PORT}"
+      else
+        get_reranker_instance_port "default"
+      fi
+      ;;
+    reranker-fine)
+      if [ -n "${RERANKER_FINE_PORT:-}" ]; then
+        echo "${RERANKER_FINE_PORT}"
+      else
+        get_reranker_instance_port "fine"
+      fi
+      ;;
     tei) echo "${TEI_PORT:-8080}" ;;
     cnclip) echo "${CNCLIP_PORT:-51000}" ;;
     *) echo "" ;;
@@ -70,6 +114,7 @@ service_start_cmd() {
     embedding-image) echo "./scripts/start_embedding_image_service.sh" ;;
     translator) echo "./scripts/start_translator.sh" ;;
     reranker) echo "./scripts/start_reranker.sh" ;;
+    reranker-fine) echo "./scripts/start_reranker.sh" ;;
     tei) echo "./scripts/start_tei_service.sh" ;;
     cnclip) echo "./scripts/start_cnclip_service.sh" ;;
     *) return 1 ;;
@@ -79,7 +124,7 @@ service_start_cmd() {
 service_exists() {
   local service="$1"
   case "${service}" in
-    backend|indexer|frontend|embedding|embedding-image|translator|reranker|tei|cnclip) return 0 ;;
+    backend|indexer|frontend|embedding|embedding-image|translator|reranker|reranker-fine|tei|cnclip) return 0 ;;
     *) return 1 ;;
   esac
 }
@@ -97,7 +142,7 @@ validate_targets() {
 health_path_for_service() {
   local service="$1"
   case "${service}" in
-    backend|indexer|embedding|embedding-image|translator|reranker|tei) echo "/health" ;;
+    backend|indexer|embedding|embedding-image|translator|reranker|reranker-fine|tei) echo "/health" ;;
     *) echo "" ;;
   esac
 }
@@ -505,7 +550,7 @@ get_cnclip_flow_device() {
 start_health_retries_for_service() {
   local service="$1"
   case "${service}" in
-    reranker) echo 90 ;;
+    reranker|reranker-fine) echo 90 ;;
     *) echo 30 ;;
   esac
 }
@@ -593,9 +638,15 @@ start_one() {
         return 1
       fi
       ;;
-    backend|indexer|frontend|embedding|embedding-image|translator|reranker)
+    backend|indexer|frontend|embedding|embedding-image|translator|reranker|reranker-fine)
       echo "[start] ${service}"
-      nohup "${cmd}" >> "${lf}" 2>&1 &
+      local rerank_instance=""
+      rerank_instance="$(reranker_instance_for_service "${service}")"
+      if [ -n "${rerank_instance}" ]; then
+        nohup env RERANK_INSTANCE="${rerank_instance}" "${cmd}" >> "${lf}" 2>&1 &
+      else
+        nohup "${cmd}" >> "${lf}" 2>&1 &
+      fi
       local pid=$!
       echo "${pid}" > "${pf}"
       wait_for_startup_health "${service}" "${pid}" "${lf}"
@@ -673,7 +724,7 @@ stop_one() {
     fi
   fi
-  if [ "${service}" = "reranker" ]; then
+  if [[ "${service}" == reranker* ]] && ! service_is_running "reranker" && ! service_is_running "reranker-fine"; then
     cleanup_reranker_orphans
   fi
 }
@@ -871,7 +922,7 @@ Special targets:
 Examples:
   ./scripts/service_ctl.sh up all
-  ./scripts/service_ctl.sh up tei cnclip embedding embedding-image translator reranker
+  ./scripts/service_ctl.sh up tei cnclip embedding embedding-image translator reranker reranker-fine
   ./scripts/service_ctl.sh up backend indexer frontend
   ./scripts/service_ctl.sh restart
   ./scripts/service_ctl.sh monitor-start all
@@ -14,9 +14,31 @@ load_env_file &quot;${PROJECT_ROOT}/.env&quot;
 # shellcheck source=scripts/lib/reranker_backend_env.sh
 source "${PROJECT_ROOT}/scripts/lib/reranker_backend_env.sh"
-RERANKER_HOST="${RERANKER_HOST:-0.0.0.0}"
-RERANKER_PORT="${RERANKER_PORT:-6007}"
-RERANK_BACKEND="${RERANK_BACKEND:-$(detect_rerank_backend "${PROJECT_ROOT}")}"
+CONFIG_PYTHON="${PROJECT_ROOT}/.venv/bin/python"
+if [[ ! -x "${CONFIG_PYTHON}" ]]; then
+  CONFIG_PYTHON="${PYTHON:-python3}"
+fi
+
+RERANK_INSTANCE="${RERANK_INSTANCE:-default}"
+
+read -r INSTANCE_HOST INSTANCE_PORT INSTANCE_BACKEND INSTANCE_RUNTIME_DIR <<EOF
+$(
+  PYTHONPATH="${PROJECT_ROOT}${PYTHONPATH:+:${PYTHONPATH}}" "${CONFIG_PYTHON}" - <<'PY'
+from config.loader import get_app_config
+import os
+
+cfg = get_app_config().services.rerank
+name = (os.getenv("RERANK_INSTANCE") or cfg.default_instance).strip() or cfg.default_instance
+instance = cfg.get_instance(name)
+runtime_dir = instance.runtime_dir or f"./.runtime/reranker/{name}"
+print(instance.host, instance.port, instance.backend, runtime_dir)
+PY
+)
+EOF
+
+RERANKER_HOST="${RERANKER_HOST:-${INSTANCE_HOST:-0.0.0.0}}"
+RERANKER_PORT="${RERANKER_PORT:-${INSTANCE_PORT:-6007}}"
+RERANK_BACKEND="${RERANK_BACKEND:-${INSTANCE_BACKEND:-$(detect_rerank_backend "${PROJECT_ROOT}")}}"
 RERANKER_VENV="${RERANKER_VENV:-$(reranker_backend_venv_dir "${PROJECT_ROOT}" "${RERANK_BACKEND}")}"
 PYTHON_BIN="${RERANKER_VENV}/bin/python"
@@ -27,7 +49,10 @@ if [[ ! -x &quot;${PYTHON_BIN}&quot; ]]; then
 fi
 # Keep vLLM/triton/torch caches out of system disk.
-RERANKER_RUNTIME_DIR="${RERANKER_RUNTIME_DIR:-${PROJECT_ROOT}/.runtime/reranker}"
+RERANKER_RUNTIME_DIR="${RERANKER_RUNTIME_DIR:-${INSTANCE_RUNTIME_DIR:-${PROJECT_ROOT}/.runtime/reranker/${RERANK_INSTANCE}}}"
+if [[ "${RERANKER_RUNTIME_DIR}" != /* ]]; then
+  RERANKER_RUNTIME_DIR="${PROJECT_ROOT}/${RERANKER_RUNTIME_DIR#./}"
+fi
 mkdir -p "${RERANKER_RUNTIME_DIR}/home" \
          "${RERANKER_RUNTIME_DIR}/cache" \
          "${RERANKER_RUNTIME_DIR}/config" \
@@ -102,6 +127,7 @@ fi
 echo "========================================"
 echo "Starting Reranker Service"
 echo "========================================"
+echo "Instance: ${RERANK_INSTANCE}"
 echo "Python: ${PYTHON_BIN}"
 echo "Host: ${RERANKER_HOST}"
 echo "Port: ${RERANKER_PORT}"
@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""
+临时脚本：从 ES 遍历指定租户的 image_url，批量调用图片 embedding 服务。
+5 进程并发，每请求最多 8 条 URL。日志打印到标准输出。
+
+用法:
+  source activate.sh   # 会加载 .env，提供 ES_HOST / ES_USERNAME / ES_PASSWORD
+  python scripts/temp_embed_tenant_image_urls.py
+
+未 source 时脚本也会尝试加载项目根目录 .env。
+"""
+
+from __future__ import annotations
+
+import json
+import multiprocessing as mp
+import os
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import urlencode
+
+import requests
+from elasticsearch import Elasticsearch
+from elasticsearch.helpers import scan
+
+# 未 source activate.sh 时仍可从项目根 .env 加载（与 ES_HOST / ES_USERNAME / ES_PASSWORD 一致）
+try:
+    from dotenv import load_dotenv
+
+    _ROOT = Path(__file__).resolve().parents[1]
+    load_dotenv(_ROOT / ".env")
+except ImportError:
+    pass
+
+# ---------------------------------------------------------------------------
+# 配置（可按需修改；默认与 .env 中 ES_* 一致，见 config/loader.py）
+# ---------------------------------------------------------------------------
+
+# Elasticsearch（默认读环境变量：ES_HOST、ES_USERNAME、ES_PASSWORD）
+ES_HOST: str = os.getenv("ES_HOST", "http://localhost:9200")
+ES_USERNAME: Optional[str] = os.getenv("ES_USERNAME") or None
+ES_PASSWORD: Optional[str] = os.getenv("ES_PASSWORD") or None
+ES_INDEX: str = "search_products_tenant_163"
+
+# 租户（keyword 字段，字符串）
+TENANT_ID: str = "163"
+
+# 图片 embedding 服务（与文档 7.1.2 一致）
+EMBED_BASE_URL: str = "http://localhost:6008"
+EMBED_PATH: str = "/embed/image"
+EMBED_QUERY: Dict[str, Any] = {
+    "normalize": "true",
+    "priority": "1",  # 与对接文档 curl 一致；批量离线可改为 "0"
+}
+
+# 并发与批量
+WORKER_PROCESSES: int = 5
+URLS_PER_REQUEST: int = 8
+
+# HTTP
+REQUEST_TIMEOUT_SEC: float = 120.0
+
+# ES scan（elasticsearch-py 8+/ES 9：`scan(..., query=...)` 会展开为 `client.search(**kwargs)`，
+# 必须传与 Search API 一致的参数名，例如顶层 `query` = DSL 的 query 子句，不要用裸 `match_all`。）
+SCROLL_CHUNK_SIZE: int = 500
+
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class BatchResult:
+    batch_index: int
+    url_count: int
+    ok: bool
+    status_code: Optional[int]
+    elapsed_sec: float
+    error: Optional[str] = None
+
+
+def _build_embed_url() -> str:
+    q = urlencode(EMBED_QUERY)
+    return f"{EMBED_BASE_URL.rstrip('/')}{EMBED_PATH}?{q}"
+
+
+def _process_batch(payload: Tuple[int, List[str]]) -> BatchResult:
+    batch_index, urls = payload
+    if not urls:
+        return BatchResult(batch_index, 0, True, None, 0.0, None)
+
+    url = _build_embed_url()
+    t0 = time.perf_counter()
+    try:
+        resp = requests.post(
+            url,
+            headers={"Content-Type": "application/json"},
+            data=json.dumps(urls),
+            timeout=REQUEST_TIMEOUT_SEC,
+        )
+        elapsed = time.perf_counter() - t0
+        ok = resp.status_code == 200
+        err: Optional[str] = None
+        if ok:
+            try:
+                body = resp.json()
+                if not isinstance(body, list) or len(body) != len(urls):
+                    ok = False
+                    err = f"response length mismatch or not list: got {type(body).__name__}"
+            except Exception as e:
+                ok = False
+                err = f"json decode: {e}"
+        else:
+            err = resp.text[:500] if resp.text else f"HTTP {resp.status_code}"
+
+        worker = mp.current_process().name
+        status = resp.status_code if resp else None
+        ms = elapsed * 1000.0
+        if ok:
+            print(
+                f"[embed] worker={worker} batch={batch_index} urls={len(urls)} "
+                f"http={status} elapsed_ms={ms:.2f} ok",
+                flush=True,
+            )
+        else:
+            print(
+                f"[embed] worker={worker} batch={batch_index} urls={len(urls)} "
+                f"http={status} elapsed_ms={ms:.2f} FAIL err={err}",
+                flush=True,
+            )
+        return BatchResult(batch_index, len(urls), ok, status, elapsed, err)
+    except Exception as e:
+        elapsed = time.perf_counter() - t0
+        worker = mp.current_process().name
+        print(
+            f"[embed] worker={worker} batch={batch_index} urls={len(urls)} "
+            f"http=None elapsed_ms={elapsed * 1000.0:.2f} FAIL err={e}",
+            flush=True,
+        )
+        return BatchResult(batch_index, len(urls), False, None, elapsed, str(e))
+
+
+def _iter_image_urls(es: Elasticsearch) -> List[str]:
+    # 对应 search body: { "query": { "term": { "tenant_id": "..." } } }
+    search_kw: Dict[str, Any] = {
+        "query": {"term": {"tenant_id": TENANT_ID}},
+        "source_includes": ["image_url"],
+    }
+    urls: List[str] = []
+    for hit in scan(
+        es,
+        query=search_kw,
+        index=ES_INDEX,
+        size=SCROLL_CHUNK_SIZE,
+    ):
+        src = hit.get("_source") or {}
+        u = src.get("image_url")
+        if u is None:
+            continue
+        s = str(u).strip()
+        if not s:
+            continue
+        urls.append(s)
+    return urls
+
+
+def main() -> int:
+    t_wall0 = time.perf_counter()
+
+    auth = None
+    if ES_USERNAME and ES_PASSWORD:
+        auth = (ES_USERNAME, ES_PASSWORD)
+
+    es = Elasticsearch([ES_HOST], basic_auth=auth)
+    if not es.ping():
+        print("ERROR: Elasticsearch ping failed", file=sys.stderr)
+        return 1
+
+    print(
+        f"[main] ES={ES_HOST} basic_auth={'yes' if auth else 'no'} "
+        f"index={ES_INDEX} tenant_id={TENANT_ID} "
+        f"workers={WORKER_PROCESSES} urls_per_req={URLS_PER_REQUEST}",
+        flush=True,
+    )
+    print(f"[main] embed_url={_build_embed_url()}", flush=True)
+
+    t_fetch0 = time.perf_counter()
+    all_urls = _iter_image_urls(es)
+    fetch_elapsed = time.perf_counter() - t_fetch0
+    print(
+        f"[main] collected image_url count={len(all_urls)} es_scan_elapsed_sec={fetch_elapsed:.3f}",
+        flush=True,
+    )
+
+    batches: List[List[str]] = []
+    for i in range(0, len(all_urls), URLS_PER_REQUEST):
+        batches.append(all_urls[i : i + URLS_PER_REQUEST])
+
+    if not batches:
+        print("[main] no URLs to process; done.", flush=True)
+        return 0
+
+    tasks = [(idx, batch) for idx, batch in enumerate(batches)]
+    print(f"[main] batches={len(tasks)} (parallel processes={WORKER_PROCESSES})", flush=True)
+
+    t_run0 = time.perf_counter()
+    total_urls = 0
+    success_urls = 0
+    failed_urls = 0
+    ok_batches = 0
+    fail_batches = 0
+    sum_req_sec = 0.0
+
+    with mp.Pool(processes=WORKER_PROCESSES) as pool:
+        for res in pool.imap_unordered(_process_batch, tasks, chunksize=1):
+            total_urls += res.url_count
+            sum_req_sec += res.elapsed_sec
+            if res.ok:
+                ok_batches += 1
+                success_urls += res.url_count
+            else:
+                fail_batches += 1
+                failed_urls += res.url_count
+
+    wall_total = time.perf_counter() - t_wall0
+    run_elapsed = time.perf_counter() - t_run0
+
+    print("---------- summary ----------", flush=True)
+    print(f"tenant_id:              {TENANT_ID}", flush=True)
+    print(f"total documents w/ url: {len(all_urls)}", flush=True)
+    print(f"total batches:          {len(batches)}", flush=True)
+    print(f"batches succeeded:      {ok_batches}", flush=True)
+    print(f"batches failed:         {fail_batches}", flush=True)
+    print(f"urls (success path):    {success_urls}", flush=True)
+    print(f"urls (failed path):     {failed_urls}", flush=True)
+    print(f"ES scan elapsed (s):    {fetch_elapsed:.3f}", flush=True)
+    print(f"embed phase wall (s):   {run_elapsed:.3f}", flush=True)
+    print(f"sum request time (s):   {sum_req_sec:.3f}  (sequential sum, for reference)", flush=True)
+    print(f"total wall time (s):    {wall_total:.3f}", flush=True)
+    print("-----------------------------", flush=True)
+    return 0 if fail_batches == 0 else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -12,6 +12,7 @@ from typing import Dict, Any, List, Optional, Tuple
 import numpy as np
 from config import FunctionScoreConfig
+from query.keyword_extractor import KEYWORDS_QUERY_BASE_KEY
 class ESQueryBuilder:
@@ -29,9 +30,17 @@ class ESQueryBuilder:
         source_fields: Optional[List[str]] = None,
         function_score_config: Optional[FunctionScoreConfig] = None,
         default_language: str = "en",
-        knn_boost: float = 0.25,
+        knn_text_boost: float = 20.0,
+        knn_image_boost: float = 20.0,
+        knn_text_k: int = 120,
+        knn_text_num_candidates: int = 400,
+        knn_text_k_long: int = 160,
+        knn_text_num_candidates_long: int = 500,
+        knn_image_k: int = 120,
+        knn_image_num_candidates: int = 400,
         base_minimum_should_match: str = "70%",
         translation_minimum_should_match: str = "70%",
+        keywords_minimum_should_match: str = "50%",
         translation_boost: float = 0.4,
         tie_breaker_base_query: float = 0.9,
         best_fields_boosts: Optional[Dict[str, float]] = None,
@@ -55,7 +64,8 @@ class ESQueryBuilder:
             source_fields: Fields to return in search results (_source includes)
             function_score_config: Function score configuration
             default_language: Default language to use when detection fails or returns "unknown"
-            knn_boost: Boost value for KNN (embedding recall)
+            knn_text_boost: Boost for text-embedding KNN clause
+            knn_image_boost: Boost for image-embedding KNN clause
         """
         self.match_fields = match_fields
         self.field_boosts = field_boosts or {}
@@ -67,9 +77,17 @@ class ESQueryBuilder:
         self.source_fields = source_fields
         self.function_score_config = function_score_config
         self.default_language = default_language
-        self.knn_boost = knn_boost
+        self.knn_text_boost = float(knn_text_boost)
+        self.knn_image_boost = float(knn_image_boost)
+        self.knn_text_k = int(knn_text_k)
+        self.knn_text_num_candidates = int(knn_text_num_candidates)
+        self.knn_text_k_long = int(knn_text_k_long)
+        self.knn_text_num_candidates_long = int(knn_text_num_candidates_long)
+        self.knn_image_k = int(knn_image_k)
+        self.knn_image_num_candidates = int(knn_image_num_candidates)
         self.base_minimum_should_match = base_minimum_should_match
         self.translation_minimum_should_match = translation_minimum_should_match
+        self.keywords_minimum_should_match = str(keywords_minimum_should_match)
         self.translation_boost = float(translation_boost)
         self.tie_breaker_base_query = float(tie_breaker_base_query)
         default_best_fields = {
@@ -171,8 +189,6 @@ class ESQueryBuilder:
         size: int = 10,
         from_: int = 0,
         enable_knn: bool = True,
-        knn_k: int = 50,
-        knn_num_candidates: int = 200,
         min_score: Optional[float] = None,
         parsed_query: Optional[Any] = None,
     ) -> Dict[str, Any]:
@@ -195,8 +211,6 @@ class ESQueryBuilder:
             size: Number of results
             from_: Offset for pagination
             enable_knn: Whether to use KNN search
-            knn_k: K value for KNN
-            knn_num_candidates: Number of candidates for KNN
             min_score: Minimum score threshold
         Returns:
@@ -234,41 +248,37 @@ class ESQueryBuilder:
             filter_clauses.append(product_title_exclusion_filter)
         # 3. Add KNN search clauses alongside lexical clauses under the same bool.should
-        # Adjust KNN k, num_candidates, boost by query_tokens (short query: less KNN; long: more)
-        final_knn_k, final_knn_num_candidates = knn_k, knn_num_candidates
+        # Text KNN: k / num_candidates from config; long queries use *_long and higher boost
         if has_embedding:
-            knn_boost = self.knn_boost
+            text_knn_boost = self.knn_text_boost
+            final_knn_k = self.knn_text_k
+            final_knn_num_candidates = self.knn_text_num_candidates
             if parsed_query:
                 query_tokens = getattr(parsed_query, 'query_tokens', None) or []
                 token_count = len(query_tokens)
                 if token_count >= 5:
-                    final_knn_k, final_knn_num_candidates = 160, 500
-                    knn_boost = self.knn_boost * 1.4  # Higher weight for long queries
-                else:
-                    final_knn_k, final_knn_num_candidates = 120, 400
-            else:
-                final_knn_k, final_knn_num_candidates = 120, 400
+                    final_knn_k = self.knn_text_k_long
+                    final_knn_num_candidates = self.knn_text_num_candidates_long
+                    text_knn_boost = self.knn_text_boost * 1.4
             recall_clauses.append({
                 "knn": {
                     "field": self.text_embedding_field,
                     "query_vector": query_vector.tolist(),
                     "k": final_knn_k,
                     "num_candidates": final_knn_num_candidates,
-                    "boost": knn_boost,
+                    "boost": text_knn_boost,
                     "_name": "knn_query",
                 }
             })
         if has_image_embedding:
-            image_knn_k = max(final_knn_k, 120)
-            image_knn_num_candidates = max(final_knn_num_candidates, 400)
             recall_clauses.append({
                 "knn": {
                     "field": self.image_embedding_field,
                     "query_vector": image_query_vector.tolist(),
-                    "k": image_knn_k,
-                    "num_candidates": image_knn_num_candidates,
-                    "boost": self.knn_boost,
+                    "k": self.knn_image_k,
+                    "num_candidates": self.knn_image_num_candidates,
+                    "boost": self.knn_image_boost,
                     "_name": "image_knn_query",
                 }
             })
@@ -498,6 +508,7 @@ class ESQueryBuilder:
         clause_name: str,
         *,
         is_source: bool,
+        keywords_query: Optional[str] = None,
     ) -> Optional[Dict[str, Any]]:
         combined_fields = self._match_field_strings(lang)
         if not combined_fields:
@@ -505,6 +516,26 @@ class ESQueryBuilder:
         minimum_should_match = (
             self.base_minimum_should_match if is_source else self.translation_minimum_should_match
         )
+        must_clauses: List[Dict[str, Any]] = [
+            {
+                "combined_fields": {
+                    "query": lang_query,
+                    "fields": combined_fields,
+                    "minimum_should_match": minimum_should_match,
+                }
+            }
+        ]
+        kw = (keywords_query or "").strip()
+        if kw:
+            must_clauses.append(
+                {
+                    "combined_fields": {
+                        "query": kw,
+                        "fields": combined_fields,
+                        "minimum_should_match": self.keywords_minimum_should_match,
+                    }
+                }
+            )
         should_clauses = [
             clause
             for clause in (
@@ -516,15 +547,7 @@ class ESQueryBuilder:
         clause: Dict[str, Any] = {
             "bool": {
                 "_name": clause_name,
-                "must": [
-                    {
-                        "combined_fields": {
-                            "query": lang_query,
-                            "fields": combined_fields,
-                            "minimum_should_match": minimum_should_match,
-                        }
-                    }
-                ],
+                "must": must_clauses,
             }
         }
         if should_clauses:
@@ -565,6 +588,11 @@ class ESQueryBuilder:
         base_query_text = (
             getattr(parsed_query, "rewritten_query", None) if parsed_query else None
         ) or query_text
+        kw_by_variant: Dict[str, str] = (
+            getattr(parsed_query, "keywords_queries", None) or {}
+            if parsed_query
+            else {}
+        )
         if base_query_text:
             base_clause = self._build_lexical_language_clause(
@@ -572,6 +600,7 @@ class ESQueryBuilder:
                 base_query_text,
                 "base_query",
                 is_source=True,
+                keywords_query=(kw_by_variant.get(KEYWORDS_QUERY_BASE_KEY) or "").strip(),
             )
             if base_clause:
                 should_clauses.append(base_clause)
@@ -583,11 +612,13 @@ class ESQueryBuilder:
                 continue
             if normalized_lang == source_lang and normalized_text == base_query_text:
                 continue
+            trans_kw = (kw_by_variant.get(normalized_lang) or "").strip()
             trans_clause = self._build_lexical_language_clause(
                 normalized_lang,
                 normalized_text,
                 f"base_query_trans_{normalized_lang}",
                 is_source=False,
+                keywords_query=trans_kw,
             )
             if trans_clause:
                 should_clauses.append(trans_clause)
@@ -10,7 +10,7 @@
 from typing import Dict, Any, List, Optional, Tuple
 import logging
-from config.schema import RerankFusionConfig
+from config.schema import CoarseRankFusionConfig, RerankFusionConfig
 from providers import create_rerank_provider
 logger = logging.getLogger(__name__)
@@ -120,6 +120,7 @@ def call_rerank_service(
     docs: List[str],
     timeout_sec: float = DEFAULT_TIMEOUT_SEC,
     top_n: Optional[int] = None,
+    service_profile: Optional[str] = None,
 ) -> Tuple[Optional[List[float]], Optional[Dict[str, Any]]]:
     """
     调用重排服务 POST /rerank，返回分数列表与 meta。
@@ -128,7 +129,7 @@ def call_rerank_service(
     if not docs:
         return [], {}
     try:
-        client = create_rerank_provider()
+        client = create_rerank_provider(service_profile=service_profile)
         return client.rerank(query=query, docs=docs, timeout_sec=timeout_sec, top_n=top_n)
     except Exception as e:
         logger.warning("Rerank request failed: %s", e, exc_info=True)
@@ -240,24 +241,105 @@ def _collect_text_score_components(matched_queries: Any, fallback_es_score: floa
 def _multiply_fusion_factors(
     rerank_score: float,
+    fine_score: Optional[float],
     text_score: float,
     knn_score: float,
     fusion: RerankFusionConfig,
-) -> Tuple[float, float, float, float]:
-    """(rerank_factor, text_factor, knn_factor, fused_without_style_boost)."""
+) -> Tuple[float, float, float, float, float]:
+    """(rerank_factor, fine_factor, text_factor, knn_factor, fused_without_style_boost)."""
     r = (max(rerank_score, 0.0) + fusion.rerank_bias) ** fusion.rerank_exponent
+    if fine_score is None:
+        f = 1.0
+    else:
+        f = (max(fine_score, 0.0) + fusion.fine_bias) ** fusion.fine_exponent
     t = (max(text_score, 0.0) + fusion.text_bias) ** fusion.text_exponent
     k = (max(knn_score, 0.0) + fusion.knn_bias) ** fusion.knn_exponent
-    return r, t, k, r * t * k
+    return r, f, t, k, r * f * t * k
+
+
+def _multiply_coarse_fusion_factors(
+    text_score: float,
+    knn_score: float,
+    fusion: CoarseRankFusionConfig,
+) -> Tuple[float, float, float]:
+    text_factor = (max(text_score, 0.0) + fusion.text_bias) ** fusion.text_exponent
+    knn_factor = (max(knn_score, 0.0) + fusion.knn_bias) ** fusion.knn_exponent
+    return text_factor, knn_factor, text_factor * knn_factor
 def _has_selected_sku(hit: Dict[str, Any]) -> bool:
     return bool(str(hit.get("_style_rerank_suffix") or "").strip())
+def coarse_resort_hits(
+    es_hits: List[Dict[str, Any]],
+    fusion: Optional[CoarseRankFusionConfig] = None,
+    debug: bool = False,
+) -> List[Dict[str, Any]]:
+    """Coarse rank with text/knn fusion only."""
+    if not es_hits:
+        return []
+
+    f = fusion or CoarseRankFusionConfig()
+    coarse_debug: List[Dict[str, Any]] = [] if debug else []
+    for hit in es_hits:
+        es_score = _to_score(hit.get("_score"))
+        matched_queries = hit.get("matched_queries")
+        knn_components = _collect_knn_score_components(matched_queries, f)
+        text_components = _collect_text_score_components(matched_queries, es_score)
+        text_score = text_components["text_score"]
+        knn_score = knn_components["knn_score"]
+        text_factor, knn_factor, coarse_score = _multiply_coarse_fusion_factors(
+            text_score=text_score,
+            knn_score=knn_score,
+            fusion=f,
+        )
+
+        hit["_text_score"] = text_score
+        hit["_knn_score"] = knn_score
+        hit["_text_knn_score"] = knn_components["text_knn_score"]
+        hit["_image_knn_score"] = knn_components["image_knn_score"]
+        hit["_coarse_score"] = coarse_score
+
+        if debug:
+            coarse_debug.append(
+                {
+                    "doc_id": hit.get("_id"),
+                    "es_score": es_score,
+                    "text_score": text_score,
+                    "text_source_score": text_components["source_score"],
+                    "text_translation_score": text_components["translation_score"],
+                    "text_weighted_source_score": text_components["weighted_source_score"],
+                    "text_weighted_translation_score": text_components["weighted_translation_score"],
+                    "text_primary_score": text_components["primary_text_score"],
+                    "text_support_score": text_components["support_text_score"],
+                    "text_score_fallback_to_es": (
+                        text_score == es_score
+                        and text_components["source_score"] <= 0.0
+                        and text_components["translation_score"] <= 0.0
+                    ),
+                    "text_knn_score": knn_components["text_knn_score"],
+                    "image_knn_score": knn_components["image_knn_score"],
+                    "weighted_text_knn_score": knn_components["weighted_text_knn_score"],
+                    "weighted_image_knn_score": knn_components["weighted_image_knn_score"],
+                    "knn_primary_score": knn_components["primary_knn_score"],
+                    "knn_support_score": knn_components["support_knn_score"],
+                    "knn_score": knn_score,
+                    "coarse_text_factor": text_factor,
+                    "coarse_knn_factor": knn_factor,
+                    "coarse_score": coarse_score,
+                    "matched_queries": matched_queries,
+                }
+            )
+
+    es_hits.sort(key=lambda h: h.get("_coarse_score", h.get("_score", 0.0)), reverse=True)
+    return coarse_debug
+
+
 def fuse_scores_and_resort(
     es_hits: List[Dict[str, Any]],
     rerank_scores: List[float],
+    fine_scores: Optional[List[float]] = None,
     weight_es: float = DEFAULT_WEIGHT_ES,
     weight_ai: float = DEFAULT_WEIGHT_AI,
     fusion: Optional[RerankFusionConfig] = None,
@@ -290,6 +372,8 @@ def fuse_scores_and_resort(
     n = len(es_hits)
     if n == 0 or len(rerank_scores) != n:
         return []
+    if fine_scores is not None and len(fine_scores) != n:
+        fine_scores = None
     f = fusion or RerankFusionConfig()
     fused_debug: List[Dict[str, Any]] = [] if debug else []
@@ -297,13 +381,14 @@ def fuse_scores_and_resort(
     for idx, hit in enumerate(es_hits):
         es_score = _to_score(hit.get("_score"))
         rerank_score = _to_score(rerank_scores[idx])
+        fine_score = _to_score(fine_scores[idx]) if fine_scores is not None else _to_score(hit.get("_fine_score"))
         matched_queries = hit.get("matched_queries")
         knn_components = _collect_knn_score_components(matched_queries, f)
         knn_score = knn_components["knn_score"]
         text_components = _collect_text_score_components(matched_queries, es_score)
         text_score = text_components["text_score"]
-        rerank_factor, text_factor, knn_factor, fused = _multiply_fusion_factors(
-            rerank_score, text_score, knn_score, f
+        rerank_factor, fine_factor, text_factor, knn_factor, fused = _multiply_fusion_factors(
+            rerank_score, fine_score if fine_scores is not None or "_fine_score" in hit else None, text_score, knn_score, f
         )
         sku_selected = _has_selected_sku(hit)
         style_boost = style_intent_selected_sku_boost if sku_selected else 1.0
@@ -311,6 +396,7 @@ def fuse_scores_and_resort(
         hit["_original_score"] = hit.get("_score")
         hit["_rerank_score"] = rerank_score
+        hit["_fine_score"] = fine_score
         hit["_text_score"] = text_score
         hit["_knn_score"] = knn_score
         hit["_text_knn_score"] = knn_components["text_knn_score"]
@@ -330,6 +416,7 @@ def fuse_scores_and_resort(
                 "doc_id": hit.get("_id"),
                 "es_score": es_score,
                 "rerank_score": rerank_score,
+                "fine_score": fine_score,
                 "text_score": text_score,
                 "text_source_score": text_components["source_score"],
                 "text_translation_score": text_components["translation_score"],
@@ -350,6 +437,7 @@ def fuse_scores_and_resort(
                 "knn_support_score": knn_components["support_knn_score"],
                 "knn_score": knn_score,
                 "rerank_factor": rerank_factor,
+                "fine_factor": fine_factor,
                 "text_factor": text_factor,
                 "knn_factor": knn_factor,
                 "style_intent_selected_sku": sku_selected,
@@ -381,6 +469,8 @@ def run_rerank(
     debug: bool = False,
     fusion: Optional[RerankFusionConfig] = None,
     style_intent_selected_sku_boost: float = 1.2,
+    fine_scores: Optional[List[float]] = None,
+    service_profile: Optional[str] = None,
 ) -> Tuple[Dict[str, Any], Optional[Dict[str, Any]], List[Dict[str, Any]]]:
     """
     完整重排流程：从 es_response 取 hits -> 构造 docs -> 调服务 -> 融合分数并重排 -> 更新 max_score。
@@ -404,6 +494,7 @@ def run_rerank(
         docs,
         timeout_sec=timeout_sec,
         top_n=top_n,
+        service_profile=service_profile,
     )
     if scores is None or len(scores) != len(hits):
@@ -412,6 +503,7 @@ def run_rerank(
     fused_debug = fuse_scores_and_resort(
         hits,
         scores,
+        fine_scores=fine_scores,
         weight_es=weight_es,
         weight_ai=weight_ai,
         fusion=fusion,
@@ -427,3 +519,53 @@ def run_rerank(
             es_response["hits"]["max_score"] = top
     return es_response, meta, fused_debug
+
+
+def run_lightweight_rerank(
+    query: str,
+    es_hits: List[Dict[str, Any]],
+    language: str = "zh",
+    timeout_sec: float = DEFAULT_TIMEOUT_SEC,
+    rerank_query_template: str = "{query}",
+    rerank_doc_template: str = "{title}",
+    top_n: Optional[int] = None,
+    debug: bool = False,
+    service_profile: Optional[str] = "fine",
+) -> Tuple[Optional[List[float]], Optional[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Call lightweight reranker and attach scores to hits without final fusion."""
+    if not es_hits:
+        return [], {}, []
+
+    query_text = str(rerank_query_template).format_map({"query": query})
+    rerank_debug_rows: Optional[List[Dict[str, Any]]] = [] if debug else None
+    docs = build_docs_from_hits(
+        es_hits,
+        language=language,
+        doc_template=rerank_doc_template,
+        debug_rows=rerank_debug_rows,
+    )
+    scores, meta = call_rerank_service(
+        query_text,
+        docs,
+        timeout_sec=timeout_sec,
+        top_n=top_n,
+        service_profile=service_profile,
+    )
+    if scores is None or len(scores) != len(es_hits):
+        return None, None, []
+
+    debug_rows: List[Dict[str, Any]] = [] if debug else []
+    for idx, hit in enumerate(es_hits):
+        fine_score = _to_score(scores[idx])
+        hit["_fine_score"] = fine_score
+        if debug:
+            row: Dict[str, Any] = {
+                "doc_id": hit.get("_id"),
+                "fine_score": fine_score,
+            }
+            if rerank_debug_rows is not None and idx < len(rerank_debug_rows):
+                row["rerank_input"] = rerank_debug_rows[idx]
+            debug_rows.append(row)
+
+    es_hits.sort(key=lambda h: h.get("_fine_score", 0.0), reverse=True)
+    return scores, meta, debug_rows
@@ -133,7 +133,14 @@ class Searcher:
             source_fields=self.source_fields,
             function_score_config=self.config.function_score,
             default_language=self.config.query_config.default_language,
-            knn_boost=self.config.query_config.knn_boost,
+            knn_text_boost=self.config.query_config.knn_text_boost,
+            knn_image_boost=self.config.query_config.knn_image_boost,
+            knn_text_k=self.config.query_config.knn_text_k,
+            knn_text_num_candidates=self.config.query_config.knn_text_num_candidates,
+            knn_text_k_long=self.config.query_config.knn_text_k_long,
+            knn_text_num_candidates_long=self.config.query_config.knn_text_num_candidates_long,
+            knn_image_k=self.config.query_config.knn_image_k,
+            knn_image_num_candidates=self.config.query_config.knn_image_num_candidates,
             base_minimum_should_match=self.config.query_config.base_minimum_should_match,
             translation_minimum_should_match=self.config.query_config.translation_minimum_should_match,
             translation_boost=self.config.query_config.translation_boost,
@@ -244,6 +251,30 @@ class Searcher:
         return hits_by_id, int(resp.get("took", 0) or 0)
     @staticmethod
+    def _restore_hits_in_doc_order(
+        doc_ids: List[str],
+        hits_by_id: Dict[str, Dict[str, Any]],
+    ) -> List[Dict[str, Any]]:
+        ordered_hits: List[Dict[str, Any]] = []
+        for doc_id in doc_ids:
+            hit = hits_by_id.get(str(doc_id))
+            if hit is not None:
+                ordered_hits.append(hit)
+        return ordered_hits
+
+    @staticmethod
+    def _merge_source_specs(*source_specs: Any) -> Optional[Dict[str, Any]]:
+        includes: set[str] = set()
+        for source_spec in source_specs:
+            if not isinstance(source_spec, dict):
+                continue
+            for field_name in source_spec.get("includes") or []:
+                includes.add(str(field_name))
+        if not includes:
+            return None
+        return {"includes": sorted(includes)}
+
+    @staticmethod
     def _has_style_intent(parsed_query: Optional[ParsedQuery]) -> bool:
         profile = getattr(parsed_query, "style_intent_profile", None)
         return bool(getattr(profile, "is_active", False))
@@ -320,20 +351,33 @@ class Searcher:
         index_langs = tenant_cfg.get("index_languages") or []
         enable_translation = len(index_langs) > 0
         enable_embedding = self.config.query_config.enable_text_embedding
+        coarse_cfg = self.config.coarse_rank
+        fine_cfg = self.config.fine_rank
         rc = self.config.rerank
         effective_query_template = rerank_query_template or rc.rerank_query_template
         effective_doc_template = rerank_doc_template or rc.rerank_doc_template
+        fine_query_template = fine_cfg.rerank_query_template or effective_query_template
+        fine_doc_template = fine_cfg.rerank_doc_template or effective_doc_template
         # 重排开关优先级：请求参数显式传值 > 服务端配置（默认开启）
         rerank_enabled_by_config = bool(rc.enabled)
         do_rerank = rerank_enabled_by_config if enable_rerank is None else bool(enable_rerank)
         rerank_window = rc.rerank_window
+        coarse_input_window = max(rerank_window, int(coarse_cfg.input_window))
+        coarse_output_window = max(rerank_window, int(coarse_cfg.output_window))
+        fine_input_window = max(rerank_window, int(fine_cfg.input_window))
+        fine_output_window = max(rerank_window, int(fine_cfg.output_window))
         # 若开启重排且请求范围在窗口内：从 ES 取前 rerank_window 条、重排后再按 from/size 分页；否则不重排，按原 from/size 查 ES
         in_rerank_window = do_rerank and (from_ + size) <= rerank_window
         es_fetch_from = 0 if in_rerank_window else from_
-        es_fetch_size = rerank_window if in_rerank_window else size
+        es_fetch_size = coarse_input_window if in_rerank_window else size
         es_score_normalization_factor: Optional[float] = None
         initial_ranks_by_doc: Dict[str, int] = {}
+        coarse_ranks_by_doc: Dict[str, int] = {}
+        fine_ranks_by_doc: Dict[str, int] = {}
+        rerank_ranks_by_doc: Dict[str, int] = {}
+        coarse_debug_info: Optional[Dict[str, Any]] = None
+        fine_debug_info: Optional[Dict[str, Any]] = None
         rerank_debug_info: Optional[Dict[str, Any]] = None
         # Start timing
@@ -360,12 +404,19 @@ class Searcher:
             'enable_rerank_request': enable_rerank,
             'rerank_query_template': effective_query_template,
             'rerank_doc_template': effective_doc_template,
+            'fine_query_template': fine_query_template,
+            'fine_doc_template': fine_doc_template,
             'filters': filters,
             'range_filters': range_filters,
             'facets': facets,
             'enable_translation': enable_translation,
             'enable_embedding': enable_embedding,
             'enable_rerank': do_rerank,
+            'coarse_input_window': coarse_input_window,
+            'coarse_output_window': coarse_output_window,
+            'fine_input_window': fine_input_window,
+            'fine_output_window': fine_output_window,
+            'rerank_window': rerank_window,
             'min_score': min_score,
             'sort_by': sort_by,
             'sort_order': sort_order
@@ -463,16 +514,12 @@ class Searcher:
             # Keep requested response _source semantics for the final response fill.
             response_source_spec = es_query.get("_source")
-            # In rerank window, first pass only fetches minimal fields required by rerank template.
+            # In multi-stage rank window, first pass only needs score signals for coarse rank.
             es_query_for_fetch = es_query
             rerank_prefetch_source = None
             if in_rerank_window:
-                rerank_prefetch_source = self._resolve_rerank_source_filter(
-                    effective_doc_template,
-                    parsed_query=parsed_query,
-                )
                 es_query_for_fetch = dict(es_query)
-                es_query_for_fetch["_source"] = rerank_prefetch_source
+                es_query_for_fetch["_source"] = False
             # Extract size and from from body for ES client parameters
             body_for_es = {k: v for k, v in es_query_for_fetch.items() if k not in ['size', 'from']}
@@ -580,26 +627,148 @@ class Searcher:
             context.end_stage(RequestContextStage.ELASTICSEARCH_SEARCH_PRIMARY)
         style_intent_decisions: Dict[str, SkuSelectionDecision] = {}
-        if self._has_style_intent(parsed_query) and in_rerank_window:
-            style_intent_decisions = self._apply_style_intent_to_hits(
-                es_response.get("hits", {}).get("hits") or [],
-                parsed_query,
-                context=context,
-            )
-            if style_intent_decisions:
+        if do_rerank and in_rerank_window:
+            from dataclasses import asdict
+            from config.services_config import get_rerank_backend_config, get_rerank_service_url
+            from .rerank_client import coarse_resort_hits, run_lightweight_rerank, run_rerank
+
+            rerank_query = parsed_query.text_for_rerank() if parsed_query else query
+            hits = es_response.get("hits", {}).get("hits") or []
+
+            context.start_stage(RequestContextStage.COARSE_RANKING)
+            try:
+                coarse_debug = coarse_resort_hits(
+                    hits,
+                    fusion=coarse_cfg.fusion,
+                    debug=debug,
+                )
+                hits = hits[:coarse_output_window]
+                es_response.setdefault("hits", {})["hits"] = hits
+                if debug:
+                    coarse_ranks_by_doc = {
+                        str(hit.get("_id")): rank
+                        for rank, hit in enumerate(hits, 1)
+                        if hit.get("_id") is not None
+                    }
+                    if debug:
+                        coarse_debug_info = {
+                            "docs_in": es_fetch_size,
+                            "docs_out": len(hits),
+                            "fusion": asdict(coarse_cfg.fusion),
+                        }
+                    context.store_intermediate_result("coarse_rank_scores", coarse_debug)
                 context.logger.info(
-                    "款式意图 SKU 预筛选完成 | hits=%s",
-                    len(style_intent_decisions),
+                    "粗排完成 | docs_in=%s | docs_out=%s",
+                    es_fetch_size,
+                    len(hits),
                     extra={'reqid': context.reqid, 'uid': context.uid}
                 )
+            finally:
+                context.end_stage(RequestContextStage.COARSE_RANKING)
+
+            ranking_source_spec = self._merge_source_specs(
+                self._resolve_rerank_source_filter(
+                    fine_doc_template,
+                    parsed_query=parsed_query,
+                ),
+                self._resolve_rerank_source_filter(
+                    effective_doc_template,
+                    parsed_query=parsed_query,
+                ),
+            )
+            candidate_ids = [str(h.get("_id")) for h in hits if h.get("_id") is not None]
+            if candidate_ids:
+                details_by_id, fill_took = self._fetch_hits_by_ids(
+                    index_name=index_name,
+                    doc_ids=candidate_ids,
+                    source_spec=ranking_source_spec,
+                )
+                for hit in hits:
+                    hid = hit.get("_id")
+                    if hid is None:
+                        continue
+                    detail_hit = details_by_id.get(str(hid))
+                    if detail_hit is not None and "_source" in detail_hit:
+                        hit["_source"] = detail_hit.get("_source") or {}
+                if fill_took:
+                    es_response["took"] = int((es_response.get("took", 0) or 0) + fill_took)
+
+            if self._has_style_intent(parsed_query):
+                style_intent_decisions = self._apply_style_intent_to_hits(
+                    es_response.get("hits", {}).get("hits") or [],
+                    parsed_query,
+                    context=context,
+                )
+                if style_intent_decisions:
+                    context.logger.info(
+                        "款式意图 SKU 预筛选完成 | hits=%s",
+                        len(style_intent_decisions),
+                        extra={'reqid': context.reqid, 'uid': context.uid}
+                    )
+
+            fine_scores: Optional[List[float]] = None
+            hits = es_response.get("hits", {}).get("hits") or []
+            if fine_cfg.enabled and hits:
+                context.start_stage(RequestContextStage.FINE_RANKING)
+                try:
+                    fine_scores, fine_meta, fine_debug_rows = run_lightweight_rerank(
+                        query=rerank_query,
+                        es_hits=hits[:fine_input_window],
+                        language=language,
+                        timeout_sec=fine_cfg.timeout_sec,
+                        rerank_query_template=fine_query_template,
+                        rerank_doc_template=fine_doc_template,
+                        top_n=fine_output_window,
+                        debug=debug,
+                        service_profile=fine_cfg.service_profile,
+                    )
+                    if fine_scores is not None:
+                        hits = hits[:fine_output_window]
+                        es_response["hits"]["hits"] = hits
+                        if debug:
+                            fine_ranks_by_doc = {
+                                str(hit.get("_id")): rank
+                                for rank, hit in enumerate(hits, 1)
+                                if hit.get("_id") is not None
+                            }
+                            fine_backend_name, fine_backend_cfg = get_rerank_backend_config(fine_cfg.service_profile)
+                            fine_debug_info = {
+                                "service_profile": fine_cfg.service_profile,
+                                "service_url": get_rerank_service_url(profile=fine_cfg.service_profile),
+                                "backend": fine_backend_name,
+                                "model": fine_meta.get("model") if isinstance(fine_meta, dict) else None,
+                                "backend_model_name": fine_backend_cfg.get("model_name"),
+                                "query_template": fine_query_template,
+                                "doc_template": fine_doc_template,
+                                "query_text": str(fine_query_template).format_map({"query": rerank_query}),
+                                "docs_in": min(len(fine_scores), fine_input_window),
+                                "docs_out": len(hits),
+                                "top_n": fine_output_window,
+                                "meta": fine_meta,
+                            }
+                            context.store_intermediate_result("fine_rank_scores", fine_debug_rows)
+                        context.logger.info(
+                            "精排完成 | docs=%s | top_n=%s | meta=%s",
+                            len(hits),
+                            fine_output_window,
+                            fine_meta,
+                            extra={'reqid': context.reqid, 'uid': context.uid}
+                        )
+                except Exception as e:
+                    context.add_warning(f"Fine rerank failed: {e}")
+                    context.logger.warning(
+                        f"调用精排服务失败 | error: {e}",
+                        extra={'reqid': context.reqid, 'uid': context.uid},
+                        exc_info=True,
+                    )
+                finally:
+                    context.end_stage(RequestContextStage.FINE_RANKING)
-        # Optional Step 4.5: AI reranking（仅当请求范围在重排窗口内时执行）
-        if do_rerank and in_rerank_window:
             context.start_stage(RequestContextStage.RERANKING)
             try:
-                from .rerank_client import run_rerank
-
-                rerank_query = parsed_query.text_for_rerank() if parsed_query else query
+                final_hits = es_response.get("hits", {}).get("hits") or []
+                final_input = final_hits[:rerank_window]
+                es_response["hits"]["hits"] = final_input
                 es_response, rerank_meta, fused_debug = run_rerank(
                     query=rerank_query,
                     es_response=es_response,
@@ -612,19 +781,30 @@ class Searcher:
                     top_n=(from_ + size),
                     debug=debug,
                     fusion=rc.fusion,
+                    fine_scores=fine_scores[:len(final_input)] if fine_scores is not None else None,
+                    service_profile=rc.service_profile,
                     style_intent_selected_sku_boost=self.config.query_config.style_intent_selected_sku_boost,
                 )
                 if rerank_meta is not None:
                     if debug:
-                        from dataclasses import asdict
-                        from config.services_config import get_rerank_service_url
+                        rerank_ranks_by_doc = {
+                            str(hit.get("_id")): rank
+                            for rank, hit in enumerate(es_response.get("hits", {}).get("hits") or [], 1)
+                            if hit.get("_id") is not None
+                        }
+                        rerank_backend_name, rerank_backend_cfg = get_rerank_backend_config(rc.service_profile)
                         rerank_debug_info = {
-                            "service_url": get_rerank_service_url(),
+                            "service_profile": rc.service_profile,
+                            "service_url": get_rerank_service_url(profile=rc.service_profile),
+                            "backend": rerank_backend_name,
+                            "model": rerank_meta.get("model") if isinstance(rerank_meta, dict) else None,
+                            "backend_model_name": rerank_backend_cfg.get("model_name"),
                             "query_template": effective_query_template,
                             "doc_template": effective_doc_template,
                             "query_text": str(effective_query_template).format_map({"query": rerank_query}),
-                            "docs": len(es_response.get("hits", {}).get("hits") or []),
+                            "docs_in": len(final_input),
+                            "docs_out": len(es_response.get("hits", {}).get("hits") or []),
                             "top_n": from_ + size,
                             "meta": rerank_meta,
                             "fusion": asdict(rc.fusion),
@@ -645,15 +825,17 @@ class Searcher:
             finally:
                 context.end_stage(RequestContextStage.RERANKING)
-        # 当本次请求在重排窗口内时：已从 ES 取了 rerank_window 条并可能已重排，需按请求的 from/size 做分页切片
+        # 当本次请求在重排窗口内时：已按多阶段排序产出前 rerank_window 条，需按请求的 from/size 做分页切片
         if in_rerank_window:
             hits = es_response.get("hits", {}).get("hits") or []
             sliced = hits[from_ : from_ + size]
             es_response.setdefault("hits", {})["hits"] = sliced
             if sliced:
-                # 对于启用重排的结果，优先使用 _fused_score 计算 max_score；否则退回原始 _score
                 slice_max = max(
-                    (h.get("_fused_score", h.get("_score", 0.0)) for h in sliced),
+                    (
+                        h.get("_fused_score", h.get("_fine_score", h.get("_coarse_score", h.get("_score", 0.0))))
+                        for h in sliced
+                    ),
                     default=0.0,
                 )
                 try:
@@ -663,7 +845,6 @@ class Searcher:
             else:
                 es_response["hits"]["max_score"] = 0.0
-            # Page fill: fetch detailed fields only for final page hits.
             if sliced:
                 if response_source_spec is False:
                     for hit in sliced:
@@ -747,6 +928,26 @@ class Searcher:
                     if doc_id is None:
                         continue
                     rerank_debug_by_doc[str(doc_id)] = item
+            coarse_debug_raw = context.get_intermediate_result('coarse_rank_scores', None)
+            coarse_debug_by_doc: Dict[str, Dict[str, Any]] = {}
+            if isinstance(coarse_debug_raw, list):
+                for item in coarse_debug_raw:
+                    if not isinstance(item, dict):
+                        continue
+                    doc_id = item.get("doc_id")
+                    if doc_id is None:
+                        continue
+                    coarse_debug_by_doc[str(doc_id)] = item
+            fine_debug_raw = context.get_intermediate_result('fine_rank_scores', None)
+            fine_debug_by_doc: Dict[str, Dict[str, Any]] = {}
+            if isinstance(fine_debug_raw, list):
+                for item in fine_debug_raw:
+                    if not isinstance(item, dict):
+                        continue
+                    doc_id = item.get("doc_id")
+                    if doc_id is None:
+                        continue
+                    fine_debug_by_doc[str(doc_id)] = item
             if self._has_style_intent(parsed_query):
                 if style_intent_decisions:
@@ -777,6 +978,12 @@ class Searcher:
                     rerank_debug = None
                     if doc_id is not None:
                         rerank_debug = rerank_debug_by_doc.get(str(doc_id))
+                    coarse_debug = None
+                    if doc_id is not None:
+                        coarse_debug = coarse_debug_by_doc.get(str(doc_id))
+                    fine_debug = None
+                    if doc_id is not None:
+                        fine_debug = fine_debug_by_doc.get(str(doc_id))
                     style_intent_debug = None
                     if doc_id is not None and style_intent_decisions:
                         decision = style_intent_decisions.get(str(doc_id))
@@ -811,11 +1018,17 @@ class Searcher:
                         "vendor_multilingual": vendor_multilingual,
                     }
+                    if coarse_debug:
+                        debug_entry["coarse_score"] = coarse_debug.get("coarse_score")
+                        debug_entry["coarse_text_factor"] = coarse_debug.get("coarse_text_factor")
+                        debug_entry["coarse_knn_factor"] = coarse_debug.get("coarse_knn_factor")
+
                     # 若存在重排调试信息，则补充 doc 级别的融合分数信息
                     if rerank_debug:
                         debug_entry["doc_id"] = rerank_debug.get("doc_id")
                         # 与 rerank_client 中字段保持一致，便于前端直接使用
                         debug_entry["rerank_score"] = rerank_debug.get("rerank_score")
+                        debug_entry["fine_score"] = rerank_debug.get("fine_score")
                         debug_entry["text_score"] = rerank_debug.get("text_score")
                         debug_entry["text_source_score"] = rerank_debug.get("text_source_score")
                         debug_entry["text_translation_score"] = rerank_debug.get("text_translation_score")
@@ -826,11 +1039,70 @@ class Searcher:
                         debug_entry["text_score_fallback_to_es"] = rerank_debug.get("text_score_fallback_to_es")
                         debug_entry["knn_score"] = rerank_debug.get("knn_score")
                         debug_entry["rerank_factor"] = rerank_debug.get("rerank_factor")
+                        debug_entry["fine_factor"] = rerank_debug.get("fine_factor")
                         debug_entry["text_factor"] = rerank_debug.get("text_factor")
                         debug_entry["knn_factor"] = rerank_debug.get("knn_factor")
                         debug_entry["fused_score"] = rerank_debug.get("fused_score")
                         debug_entry["rerank_input"] = rerank_debug.get("rerank_input")
                         debug_entry["matched_queries"] = rerank_debug.get("matched_queries")
+                    elif fine_debug:
+                        debug_entry["doc_id"] = fine_debug.get("doc_id")
+                        debug_entry["fine_score"] = fine_debug.get("fine_score")
+                        debug_entry["rerank_input"] = fine_debug.get("rerank_input")
+
+                    initial_rank = initial_ranks_by_doc.get(str(doc_id)) if doc_id is not None else None
+                    coarse_rank = coarse_ranks_by_doc.get(str(doc_id)) if doc_id is not None else None
+                    fine_rank = fine_ranks_by_doc.get(str(doc_id)) if doc_id is not None else None
+                    rerank_rank = rerank_ranks_by_doc.get(str(doc_id)) if doc_id is not None else None
+                    final_rank = final_ranks_by_doc.get(str(doc_id)) if doc_id is not None else None
+
+                    def _rank_change(previous_rank: Optional[int], current_rank: Optional[int]) -> Optional[int]:
+                        if previous_rank is None or current_rank is None:
+                            return None
+                        return previous_rank - current_rank
+
+                    debug_entry["ranking_funnel"] = {
+                        "es_recall": {
+                            "rank": initial_rank,
+                            "score": es_score,
+                            "normalized_score": normalized,
+                            "matched_queries": hit.get("matched_queries"),
+                        },
+                        "coarse_rank": {
+                            "rank": coarse_rank,
+                            "rank_change": _rank_change(initial_rank, coarse_rank),
+                            "score": coarse_debug.get("coarse_score") if coarse_debug else None,
+                            "text_score": coarse_debug.get("text_score") if coarse_debug else None,
+                            "knn_score": coarse_debug.get("knn_score") if coarse_debug else None,
+                            "text_factor": coarse_debug.get("coarse_text_factor") if coarse_debug else None,
+                            "knn_factor": coarse_debug.get("coarse_knn_factor") if coarse_debug else None,
+                            "signals": coarse_debug,
+                        },
+                        "fine_rank": {
+                            "rank": fine_rank,
+                            "rank_change": _rank_change(coarse_rank, fine_rank),
+                            "score": fine_debug.get("fine_score") if fine_debug else hit.get("_fine_score"),
+                            "rerank_input": fine_debug.get("rerank_input") if fine_debug else None,
+                        },
+                        "rerank": {
+                            "rank": rerank_rank,
+                            "rank_change": _rank_change(fine_rank, rerank_rank),
+                            "rerank_score": rerank_debug.get("rerank_score") if rerank_debug else hit.get("_rerank_score"),
+                            "fine_score": rerank_debug.get("fine_score") if rerank_debug else hit.get("_fine_score"),
+                            "fused_score": rerank_debug.get("fused_score") if rerank_debug else hit.get("_fused_score"),
+                            "text_score": rerank_debug.get("text_score") if rerank_debug else hit.get("_text_score"),
+                            "knn_score": rerank_debug.get("knn_score") if rerank_debug else hit.get("_knn_score"),
+                            "rerank_factor": rerank_debug.get("rerank_factor") if rerank_debug else None,
+                            "fine_factor": rerank_debug.get("fine_factor") if rerank_debug else None,
+                            "text_factor": rerank_debug.get("text_factor") if rerank_debug else None,
+                            "knn_factor": rerank_debug.get("knn_factor") if rerank_debug else None,
+                            "signals": rerank_debug,
+                        },
+                        "final_page": {
+                            "rank": final_rank,
+                            "rank_change": _rank_change(rerank_rank, final_rank),
+                        },
+                    }
                     if style_intent_debug:
                         debug_entry["style_intent_sku"] = style_intent_debug
@@ -901,7 +1173,18 @@ class Searcher:
                     "shards": es_response.get('_shards', {}),
                     "es_score_normalization_factor": es_score_normalization_factor,
                 },
+                "coarse_rank": coarse_debug_info,
+                "fine_rank": fine_debug_info,
                 "rerank": rerank_debug_info,
+                "ranking_funnel": {
+                    "es_recall": {
+                        "docs_out": es_fetch_size,
+                        "score_normalization_factor": es_score_normalization_factor,
+                    },
+                    "coarse_rank": coarse_debug_info,
+                    "fine_rank": fine_debug_info,
+                    "rerank": rerank_debug_info,
+                },
                 "feature_flags": context.metadata.get('feature_flags', {}),
                 "stage_timings": {
                     k: round(v, 2) for k, v in context.performance_metrics.stage_timings.items()
@@ -0,0 +1,43 @@
+白色oversized T-shirt
+falda negra oficina
+red fitted tee
+黒いミディ丈スカート
+黑色中长半身裙
+فستان أسود متوسط الطول
+чёрное летнее платье
+修身牛仔裤
+date night dress
+vacation outfit dress
+minimalist top
+streetwear t-shirt
+office casual blouse
+街头风T恤
+宽松T恤
+复古印花T恤
+Y2K上衣
+情侣T恤
+美式复古T恤
+重磅棉T恤
+修身打底衫
+辣妹风短袖
+纯欲上衣
+正肩白T恤
+波西米亚花朵衬衫
+泡泡袖短袖
+扎染字母T恤
+T-shirt Dress
+Crop Top
+Lace Undershirt
+Leopard Print Ripped T-shirt
+Breton Stripe T-shirt
+V-Neck Cotton T-shirt
+Sweet & Cool Bow T-shirt
+Vacation Style T-shirt
+Commuter Casual Top
+Minimalist Solid T-shirt
+Band T-shirt
+Athletic Gym T-shirt
+Plus Size Loose T-shirt
+Korean Style Slim T-shirt
+Basic Layering Top
+
@@ -119,9 +119,12 @@ def test_text_query_skips_duplicate_translation_same_as_base():
         enable_knn=False,
     )
-    root = _recall_root(q)
-    assert root["bool"]["_name"] == "base_query"
-    assert [clause["multi_match"]["type"] for clause in root["bool"]["should"]] == ["best_fields", "phrase"]
+    query_root = q["query"]
+    if "function_score" in query_root:
+        query_root = query_root["function_score"]["query"]
+    base_bool = query_root["bool"]
+    assert base_bool["_name"] == "base_query"
+    assert [clause["multi_match"]["type"] for clause in base_bool["should"]] == ["best_fields", "phrase"]
 def test_product_title_exclusion_filter_is_applied_once_on_outer_query():
@@ -11,6 +11,7 @@ from typing import Any, Dict, List
 import numpy as np
+from query.keyword_extractor import KEYWORDS_QUERY_BASE_KEY
 from search.es_query_builder import ESQueryBuilder
@@ -129,6 +130,29 @@ def test_zh_query_index_zh_en_includes_base_zh_and_trans_en():
     assert "title.en" in _title_fields(idx["base_query_trans_en"])
+def test_keywords_combined_fields_second_must_same_fields_and_50pct():
+    """When ParsedQuery.keywords_queries is set, must includes a second combined_fields."""
+    qb = _builder_multilingual_title_only(default_language="en")
+    parsed = SimpleNamespace(
+        rewritten_query="连衣裙",
+        detected_language="zh",
+        translations={"en": "red dress"},
+        keywords_queries={KEYWORDS_QUERY_BASE_KEY: "连衣 裙", "en": "dress"},
+    )
+    q = qb.build_query(query_text="连衣裙", parsed_query=parsed, enable_knn=False)
+    idx = _clauses_index(q)
+    base = idx["base_query"]
+    assert len(base["must"]) == 2
+    assert base["must"][0]["combined_fields"]["query"] == "连衣裙"
+    assert base["must"][1]["combined_fields"]["query"] == "连衣 裙"
+    assert base["must"][1]["combined_fields"]["minimum_should_match"] == "50%"
+    assert base["must"][1]["combined_fields"]["fields"] == base["must"][0]["combined_fields"]["fields"]
+    trans = idx["base_query_trans_en"]
+    assert len(trans["must"]) == 2
+    assert trans["must"][1]["combined_fields"]["query"] == "dress"
+    assert trans["must"][1]["combined_fields"]["minimum_should_match"] == "50%"
+
+
 def test_en_query_index_zh_en_includes_base_en_and_trans_zh():
     qb = _builder_multilingual_title_only(default_language="en")
     q = _build(
@@ -351,7 +375,10 @@ def test_text_clauses_present_alongside_knn():
         parsed_query=parsed,
         enable_knn=True,
     )
-    assert "knn" in q
+    qr = q["query"]
+    if "function_score" in qr:
+        qr = qr["function_score"]["query"]
+    assert any("knn" in c for c in qr["bool"]["should"])
     idx = _clauses_index(q)
     assert set(idx) == {"base_query", "base_query_trans_zh"}
@@ -0,0 +1,115 @@
+import hanlp
+from typing import List, Tuple, Dict, Any
+
+class KeywordExtractor:
+    """
+    基于 HanLP 的名词关键词提取器
+    """
+    def __init__(self):
+        # 加载带位置信息的分词模型（细粒度）
+        self.tok = hanlp.load(hanlp.pretrained.tok.CTB9_TOK_ELECTRA_BASE_CRF)
+        self.tok.config.output_spans = True   # 启用位置输出
+        
+        # 加载词性标注模型
+        self.pos_tag = hanlp.load(hanlp.pretrained.pos.CTB9_POS_ELECTRA_SMALL)
+        
+    def extract_keywords(self, query: str) -> str:
+        """
+        从查询中提取关键词（名词，长度 ≥ 2）
+        
+        Args:
+            query: 输入文本
+            
+        Returns:
+            拼接后的关键词字符串，非连续词之间自动插入空格
+        """
+        query = query.strip()
+        # 分词结果带位置：[[word, start, end], ...]
+        tok_result_with_position = self.tok(query)
+        tok_result = [x[0] for x in tok_result_with_position]
+        
+        # 词性标注
+        pos_tag_result = list(zip(tok_result, self.pos_tag(tok_result)))
+        
+        # 需要忽略的词
+        ignore_keywords = ['玩具']
+        
+        keywords = []
+        last_end_pos = 0
+        
+        for (word, postag), (_, start_pos, end_pos) in zip(pos_tag_result, tok_result_with_position):
+            if len(word) >= 2 and postag.startswith('N'):
+                if word in ignore_keywords:
+                    continue
+                # 如果当前词与上一个词在原文中不连续，插入空格
+                if start_pos != last_end_pos and keywords:
+                    keywords.append(" ")
+                keywords.append(word)
+                last_end_pos = end_pos
+            # 可选：打印调试信息
+            # print(f'分词: {word} | 词性: {postag} | 起始: {start_pos} | 结束: {end_pos}')
+        
+        return "".join(keywords).strip()
+
+
+# 测试代码
+if __name__ == "__main__":
+    extractor = KeywordExtractor()
+    
+    test_queries = [
+        # 中文（保留 9 个代表性查询）
+        "2.4G遥控大蛇",
+        "充气的篮球",
+        "遥控 塑料 飞船 汽车 ",
+        "亚克力相框",
+        "8寸 搪胶蘑菇钉",
+        "7寸娃娃",
+        "太空沙套装",
+        "脚蹬工程车",
+        "捏捏乐钥匙扣",
+        
+        # 英文（新增）
+        "plastic toy car",
+        "remote control helicopter",
+        "inflatable beach ball",
+        "music keychain",
+        "sand play set",
+        # 常见商品搜索
+        "plastic dinosaur toy",
+        "wireless bluetooth speaker",
+        "4K action camera",
+        "stainless steel water bottle",
+        "baby stroller with cup holder",
+        
+        # 疑问式 / 自然语言
+        "what is the best smartphone under 500 dollars",
+        "how to clean a laptop screen",
+        "where can I buy organic coffee beans",
+        
+        # 含数字、特殊字符
+        "USB-C to HDMI adapter 4K",
+        "LED strip lights 16.4ft",
+        "Nintendo Switch OLED model",
+        "iPhone 15 Pro Max case",
+        
+        # 简短词组
+        "gaming mouse",
+        "mechanical keyboard",
+        "wireless earbuds",
+        
+        # 长尾词
+        "rechargeable AA batteries with charger",
+        "foldable picnic blanket waterproof",
+        
+        # 商品属性组合
+        "women's running shoes size 8",
+        "men's cotton t-shirt crew neck",
+
+            
+        # 其他语种（保留原样，用于多语言测试）
+        "свет USB с пультом дистанционного управления красочные",  # 俄语
+    ]
+    
+    for q in test_queries:
+        keywords = extractor.extract_keywords(q)
+        print(f"{q:30} => {keywords}")
@@ -299,6 +299,73 @@ def test_config_loader_rerank_enabled_defaults_true(tmp_path: Path):
     assert loaded.rerank.enabled is True
+def test_config_loader_parses_named_rerank_instances(tmp_path: Path):
+    from config.loader import AppConfigLoader
+
+    config_data = {
+        "es_index_name": "test_products",
+        "field_boosts": {"title.en": 3.0},
+        "indexes": [{"name": "default", "label": "default", "fields": ["title.en"]}],
+        "query_config": {"supported_languages": ["en"], "default_language": "en"},
+        "services": {
+            "translation": {
+                "service_url": "http://localhost:6005",
+                "timeout_sec": 3.0,
+                "default_model": "dummy-model",
+                "default_scene": "general",
+                "cache": {"ttl_seconds": 60, "sliding_expiration": True},
+                "capabilities": {
+                    "dummy-model": {
+                        "enabled": True,
+                        "backend": "llm",
+                        "model": "dummy-model",
+                        "base_url": "http://localhost:6005/v1",
+                        "timeout_sec": 3.0,
+                        "use_cache": True,
+                    }
+                },
+            },
+            "embedding": {
+                "provider": "http",
+                "providers": {"http": {"text_base_url": "http://localhost:6005", "image_base_url": "http://localhost:6008"}},
+                "backend": "tei",
+                "backends": {"tei": {"base_url": "http://localhost:8080", "model_id": "dummy-embedding-model"}},
+            },
+            "rerank": {
+                "provider": "http",
+                "providers": {
+                    "http": {
+                        "instances": {
+                            "default": {"service_url": "http://localhost:6007/rerank"},
+                            "fine": {"service_url": "http://localhost:6009/rerank"},
+                        }
+                    }
+                },
+                "default_instance": "default",
+                "instances": {
+                    "default": {"port": 6007, "backend": "qwen3_vllm_score"},
+                    "fine": {"port": 6009, "backend": "bge"},
+                },
+                "backends": {
+                    "bge": {"model_name": "BAAI/bge-reranker-v2-m3"},
+                    "qwen3_vllm_score": {"model_name": "Qwen/Qwen3-Reranker-0.6B"},
+                },
+            },
+        },
+        "spu_config": {"enabled": False},
+        "function_score": {"score_mode": "sum", "boost_mode": "multiply", "functions": []},
+    }
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text(yaml.safe_dump(config_data), encoding="utf-8")
+
+    loader = AppConfigLoader(config_file=config_path)
+    loaded = loader.load(validate=False)
+
+    assert loaded.services.rerank.default_instance == "default"
+    assert loaded.services.rerank.get_instance("fine").port == 6009
+    assert loaded.services.rerank.get_instance("fine").backend == "bge"
+
+
 def test_searcher_reranks_top_window_by_default(monkeypatch):
     es_client = _FakeESClient()
     searcher = _build_searcher(_build_search_config(rerank_enabled=True), es_client)
@@ -311,11 +378,18 @@ def test_searcher_reranks_top_window_by_default(monkeypatch):
     called: Dict[str, Any] = {"count": 0, "docs": 0}
+    def _fake_run_lightweight_rerank(**kwargs):
+        hits = kwargs["es_hits"]
+        for idx, hit in enumerate(hits):
+            hit["_fine_score"] = float(len(hits) - idx)
+        return [hit["_fine_score"] for hit in hits], {"stage": "fine"}, []
+
     def _fake_run_rerank(**kwargs):
         called["count"] += 1
         called["docs"] = len(kwargs["es_response"]["hits"]["hits"])
         return kwargs["es_response"], None, []
+    monkeypatch.setattr("search.rerank_client.run_lightweight_rerank", _fake_run_lightweight_rerank)
     monkeypatch.setattr("search.rerank_client.run_rerank", _fake_run_rerank)
     result = searcher.search(
@@ -328,22 +402,101 @@ def test_searcher_reranks_top_window_by_default(monkeypatch):
     )
     assert called["count"] == 1
-    # 应当对配置的 rerank_window 条文档做重排预取
-    window = searcher.config.rerank.rerank_window
-    assert called["docs"] == window
+    assert called["docs"] == searcher.config.rerank.rerank_window
     assert es_client.calls[0]["from_"] == 0
-    assert es_client.calls[0]["size"] == window
+    assert es_client.calls[0]["size"] == searcher.config.coarse_rank.input_window
     assert es_client.calls[0]["include_named_queries_score"] is True
-    assert es_client.calls[0]["body"]["_source"] == {"includes": ["title"]}
-    assert len(es_client.calls) == 2
-    assert es_client.calls[1]["size"] == 10
+    assert es_client.calls[0]["body"]["_source"] is False
+    assert len(es_client.calls) == 3
+    assert es_client.calls[1]["size"] == max(
+        searcher.config.coarse_rank.output_window,
+        searcher.config.rerank.rerank_window,
+    )
     assert es_client.calls[1]["from_"] == 0
-    assert es_client.calls[1]["body"]["query"]["ids"]["values"] == [str(i) for i in range(20, 30)]
+    assert es_client.calls[2]["size"] == 10
+    assert es_client.calls[2]["from_"] == 0
+    assert es_client.calls[2]["body"]["query"]["ids"]["values"] == [str(i) for i in range(20, 30)]
     assert len(result.results) == 10
     assert result.results[0].spu_id == "20"
     assert result.results[0].brief == "brief-20"
+def test_searcher_debug_info_exposes_ranking_funnel(monkeypatch):
+    es_client = _FakeESClient(total_hits=120)
+    searcher = _build_searcher(_build_search_config(rerank_enabled=True, rerank_window=20), es_client)
+    context = create_request_context(reqid="t-debug", uid="u-debug")
+
+    monkeypatch.setattr(
+        "search.searcher.get_tenant_config_loader",
+        lambda: SimpleNamespace(get_tenant_config=lambda tenant_id: {"index_languages": ["en"]}),
+    )
+
+    def _fake_run_lightweight_rerank(**kwargs):
+        hits = kwargs["es_hits"]
+        scores = []
+        debug_rows = []
+        for idx, hit in enumerate(hits):
+            score = float(len(hits) - idx)
+            hit["_fine_score"] = score
+            scores.append(score)
+            debug_rows.append(
+                {
+                    "doc_id": hit["_id"],
+                    "fine_score": score,
+                    "rerank_input": {"doc_preview": f"product-{hit['_id']}"},
+                }
+            )
+        hits.sort(key=lambda item: item["_fine_score"], reverse=True)
+        return scores, {"model": "fine-bge"}, debug_rows
+
+    def _fake_run_rerank(**kwargs):
+        hits = kwargs["es_response"]["hits"]["hits"]
+        fused_debug = []
+        for idx, hit in enumerate(hits):
+            hit["_rerank_score"] = 10.0 - idx
+            hit["_fused_score"] = 100.0 - idx
+            hit["_text_score"] = hit.get("_score", 0.0)
+            hit["_knn_score"] = 0.0
+            fused_debug.append(
+                {
+                    "doc_id": hit["_id"],
+                    "rerank_score": hit["_rerank_score"],
+                    "fine_score": hit.get("_fine_score"),
+                    "text_score": hit["_text_score"],
+                    "knn_score": 0.0,
+                    "rerank_factor": 1.0,
+                    "fine_factor": 1.0,
+                    "text_factor": 1.0,
+                    "knn_factor": 1.0,
+                    "fused_score": hit["_fused_score"],
+                    "matched_queries": {},
+                    "rerank_input": {"doc_preview": f"product-{hit['_id']}"},
+                }
+            )
+        return kwargs["es_response"], {"model": "final-reranker"}, fused_debug
+
+    monkeypatch.setattr("search.rerank_client.run_lightweight_rerank", _fake_run_lightweight_rerank)
+    monkeypatch.setattr("search.rerank_client.run_rerank", _fake_run_rerank)
+
+    result = searcher.search(
+        query="toy",
+        tenant_id="162",
+        from_=0,
+        size=5,
+        context=context,
+        enable_rerank=True,
+        debug=True,
+    )
+
+    assert result.debug_info["ranking_funnel"]["fine_rank"]["docs_out"] == 80
+    assert result.debug_info["ranking_funnel"]["rerank"]["docs_out"] == 20
+    first = result.debug_info["per_result"][0]["ranking_funnel"]
+    assert first["es_recall"]["rank"] is not None
+    assert first["coarse_rank"]["score"] is not None
+    assert first["fine_rank"]["score"] is not None
+    assert first["rerank"]["rerank_score"] is not None
+
+
 def test_searcher_rerank_prefetch_source_follows_doc_template(monkeypatch):
     es_client = _FakeESClient()
     searcher = _build_searcher(_build_search_config(rerank_enabled=True), es_client)
@@ -353,6 +506,10 @@ def test_searcher_rerank_prefetch_source_follows_doc_template(monkeypatch):
         "search.searcher.get_tenant_config_loader",
         lambda: SimpleNamespace(get_tenant_config=lambda tenant_id: {"index_languages": ["en"]}),
     )
+    monkeypatch.setattr(
+        "search.rerank_client.run_lightweight_rerank",
+        lambda **kwargs: ([1.0] * len(kwargs["es_hits"]), {"stage": "fine"}, []),
+    )
     monkeypatch.setattr("search.rerank_client.run_rerank", lambda **kwargs: (kwargs["es_response"], None, []))
     searcher.search(
@@ -365,7 +522,8 @@ def test_searcher_rerank_prefetch_source_follows_doc_template(monkeypatch):
         rerank_doc_template="{title} {vendor} {brief}",
     )
-    assert es_client.calls[0]["body"]["_source"] == {"includes": ["brief", "title", "vendor"]}
+    assert es_client.calls[0]["body"]["_source"] is False
+    assert es_client.calls[1]["body"]["_source"] == {"includes": ["brief", "title", "vendor"]}
 def test_searcher_rerank_prefetch_source_includes_sku_fields_when_style_intent_active(monkeypatch):
@@ -378,6 +536,10 @@ def test_searcher_rerank_prefetch_source_includes_sku_fields_when_style_intent_a
         lambda: SimpleNamespace(get_tenant_config=lambda tenant_id: {"index_languages": ["en"]}),
     )
     monkeypatch.setattr(
+        "search.rerank_client.run_lightweight_rerank",
+        lambda **kwargs: ([1.0] * len(kwargs["es_hits"]), {"stage": "fine"}, []),
+    )
+    monkeypatch.setattr(
         "search.rerank_client.run_rerank",
         lambda **kwargs: (kwargs["es_response"], None, []),
     )
@@ -414,7 +576,8 @@ def test_searcher_rerank_prefetch_source_includes_sku_fields_when_style_intent_a
         enable_rerank=None,
     )
-    assert es_client.calls[0]["body"]["_source"] == {
+    assert es_client.calls[0]["body"]["_source"] is False
+    assert es_client.calls[1]["body"]["_source"] == {
         "includes": ["option1_name", "option2_name", "option3_name", "skus", "title"]
     }