Auto-sync from GitHub Actions

README.md

@@ -43,6 +43,7 @@ thumbnail: >-
 * **多维度语义匹配：** 底层支持 4 个维度的向量空间检索（英文、中文扩展词、维基释义、中文核心词），大幅提升模糊描述的命中率。
 * **智能分词与显式分隔：** 支持一键开启/关闭自动分词。开启后自动提取长句中概念分别检索；同时支持用空格、换行、中文逗号（，）和顿号（、）手动分隔概念，系统会尊重你的分隔意图，将每个片段作为整体匹配（超过 7 字的片段仍然自动分词）。
 * **标签互相关推荐：** 引擎内置标签共现数据。当你选中某些标签后，系统会自动推荐在 Danbooru 图库中经常与它们一同出现的相关标签，辅助补全画面细节。
+* **推荐擅长画师：** 基于标签-画师 NPMI 共现数据，根据已选标签实时推荐擅长绘制这些元素的画师，支持勾选加入已选标签。
 * **精细化查阅与过滤：** 支持按标签类别（General通用 / Character角色 / Copyright作品）进行硬过滤。
   * 提供 **NSFW 保护模式**（开启后自动模糊敏感词汇）。
   * 表格内置 Danbooru 维基释义悬浮提示，并提供前往原站的快捷链接。
@@ -50,15 +51,16 @@ thumbnail: >-
 
 ## 功能概览
 
-本工具提供以下五项核心功能：
+本工具提供以下核心功能：
 
 - [精确查词](#1-精确查词)（容错拼写错误）
 - [概念模糊发散](#2-概念模糊发散)
 - [输入描述查词](#3-输入描述查词)
 - [完整画面查找](#4-完整画面查找)
 - [关联推荐](#5-关联推荐共现匹配)
+- [推荐擅长画师](#6-推荐擅长画师)
 
-前四项基于**语义向量匹配**，后一项基于**标签共现数据**。
+前四项基于**语义向量匹配**，后两项基于**标签-画师共现数据**。
 
 ---
 
@@ -277,6 +279,30 @@ thumbnail: >-
 
 ---
 
+## 6. 推荐擅长画师
+
+推荐擅长画师与关联推荐类似，基于 **标签-画师 NPMI 共现数据**，但目标是推荐擅长绘制已选标签所描述元素的画师。
+
+**使用方式：** 在左侧结果表格或右侧关联推荐中勾选标签后，右栏「推荐擅长画师」区域会**实时自动更新**，无需手动刷新。画师可勾选加入已选标签（Anima 模式下复制时自动加 `@` 前缀）。
+
+**评分逻辑：** 对每个已选标签，计算该标签与画师的 NPMI 共现分，累加后乘以命中标签数加成，最终归一化显示为百分比。
+
+### 适用场景
+
+**场景 1：根据风格标签找画师**
+
+勾选 `flat_color`（平涂）+ `1girl`，推荐擅长平涂风格女性角色的画师。
+
+**场景 2：根据角色找画师**
+
+勾选某角色标签，推荐经常绘制该角色的画师。
+
+**场景 3：根据画面元素找画师**
+
+勾选 `mecha`（机甲）+ `detailed_background`，推荐擅长机甲和精细背景的画师。
+
+---
+
 ## 使用技巧
 
 **技巧 1：先宽后窄**
@@ -331,6 +357,16 @@ POST /api/related
 }
 ```
 
+**推荐擅长画师接口**
+```
+POST /api/artists
+{
+    "tags": ["1girl", "blue_hair", "school_uniform"],
+    "limit": 30,
+    "min_cooc": 3
+}
+```
+
 详见：[API 文档](https://sakizuki-danboorusearch.hf.space/api/docs)
 
 ---
@@ -381,7 +417,7 @@ npm install -g mcp-remote
 }
 ```
 
-保存后重启 Claude Desktop，工具列表中出现 `search_tags` 和 `get_related_tags` 即为成功。
+保存后重启 Claude Desktop，工具列表中出现 `search_tags`、`get_related_tags` 和 `get_artist_recommendations` 即为成功。
 
 > 注意：不要使用 `"url"` 字段直接填写地址，Claude Desktop 不支持该格式，会提示配置无效。也不推荐通过 `npx mcp-remote` 调用，首次执行时 `npx` 需要临时下载包，npm 缓存损坏时会导致启动失败。全局安装可规避此问题。
 
@@ -399,7 +435,7 @@ npm install -g mcp-remote
 
 ### 可用工具
 
-接入后 AI 可调用以下两个工具：
+接入后 AI 可调用以下工具：
 
 **`search_tags`** — 自然语言搜索标签
 
@@ -419,6 +455,17 @@ npm install -g mcp-remote
 
 给定一组已选标签，返回在 Danbooru 图库中与之最常共现的相关标签，基于 NPMI 评分，可有效过滤掉仅因自身热度高而频繁出现的标签。
 
+**`get_artist_recommendations`** — 推荐擅长画师
+
+给定一组标签，返回擅长绘制这些元素的画师列表，基于标签-画师 NPMI 共现数据排序。
+
+| 参数 | 默认值 | 说明 |
+|---|---|---|
+| `tags` | — | 标签列表（必填，Danbooru 英文标签名） |
+| `limit` | `30` | 最多返回画师数 |
+| `min_cooc` | `3` | 单个 (tag, artist) 对的最小共现次数 |
+| `show_nsfw` | `true` | 是否包含 NSFW 数据 |
+
 ### 调用示例
 
 接入后，你可以直接用自然语言告诉 AI 你的需求，AI 会自动选择合适的参数调用工具：
@@ -431,6 +478,8 @@ npm install -g mcp-remote
 
 > 我已经选了 `white_serafuku` 和 `rain` 这两个标签，帮我推荐一些常见的搭配标签
 
+> 帮我找擅长画「平涂风格 + 蓝发少女」的画��
+
 > 查一下「运动社团 校队 比赛 运动会 体育祭 田径部 网球部 篮球部」这些概念对应的标签
 
 > 找「反乌托邦、赛博朋克、蒸汽朋克」的 General 类标签，只查通用特征不查作品名

api_fastapi.py

@@ -88,6 +88,21 @@ class SearchOut(BaseModel):
     keywords: list[str]
 
 
+class ArtistIn(BaseModel):
+    tags: list[str]
+    limit: int = Field(30, ge=1, le=100)
+    min_cooc: int = Field(3, ge=1, le=100)
+
+
+class ArtistOut(BaseModel):
+    artist: str
+    score: float
+    cooc_count: int
+    post_count: int
+    sources: list[str]
+    hit_count: int
+
+
 # ── FastAPI 子应用（挂载到 NiceGUI 的 /api 路径下）──
 # lifespan / 预热由 ui_nicegui.py 的 @app.on_startup 统一管理，此处不重复。
 app = FastAPI(
@@ -162,6 +177,37 @@ async def related(body: RelatedIn) -> list[RelatedTagOut]:
     ]
 
 
+@app.post("/artists", response_model=list[ArtistOut])
+async def artists(body: ArtistIn) -> list[ArtistOut]:
+    """
+    给定标签列表，推荐擅长绘制这些标签的画师（基于 NPMI 共现数据）。
+
+    - tags：种子标签列表（Danbooru 英文标签名）
+    - limit：最多返回条数，默认 30
+    - min_cooc：单个 (tag, artist) 对的最小共现次数，默认 3
+    """
+    tagger = await DanbooruTagger.get_instance()
+    results = await tagger.search_artists_by_tags_async(
+        body.tags, limit=body.limit, min_cooc=body.min_cooc,
+    )
+    # 计数
+    await counter.increment()
+    await counter.increment_success()
+    await counter.increment_copy()
+
+    return [
+        ArtistOut(
+            artist=r.artist,
+            score=round(r.score, 4),
+            cooc_count=r.cooc_count,
+            post_count=r.post_count,
+            sources=r.sources,
+            hit_count=r.hit_count,
+        )
+        for r in results
+    ]
+
+
 @app.get("/health")
 async def health():
     tagger = await DanbooruTagger.get_instance()

core/engine.py

@@ -214,6 +214,7 @@ class DanbooruTagger:
         self._group_to_tags_idx: dict[str, np.ndarray]            = {}
         self._group_cn_names: dict[str, str]                      = {}
         self._tag_artist_index: dict[str, list[tuple]]           = {}
+        self._artist_top_tags: dict[str, list[tuple]]            = {}  # artist → [(tag, npmi, cn_short), ...]
         self.is_loaded:     bool                                  = False
 
         # 预提取的列数组，避免热点路径上反复执行 df.iloc[idx]
@@ -1280,6 +1281,37 @@ class DanbooruTagger:
             ))
         return results
 
+    def get_artist_top_tags(self, artist_names: list[str], top_n: int = 10,
+                            show_nsfw: bool = True) -> dict[str, list[str]]:
+        """获取画师的 top-N 共现标签（含中文简称）。
+
+        Returns:
+            {artist: [f"{tag} ({cn_short})", ...]}
+        """
+        result: dict[str, list[str]] = {}
+        for artist in artist_names:
+            entries = self._artist_top_tags.get(artist, [])
+            items: list[str] = []
+            for tag, npmi, cooc in entries:
+                if len(items) >= top_n:
+                    break
+                # NSFW 过滤
+                if not show_nsfw and self._name_to_idx is not None and tag in self._name_to_idx:
+                    idx = self._name_to_idx[tag]
+                    if self._arr_nsfw is not None and self._arr_nsfw[idx] == '1':
+                        continue
+                cn_short = ""
+                if self._name_to_idx is not None and tag in self._name_to_idx:
+                    idx = self._name_to_idx[tag]
+                    cn_full = str(self._arr_cn_name[idx]) if self._arr_cn_name is not None else ""
+                    cn_short = cn_full.split(',')[0].strip() if cn_full else ""
+                display = f"{tag}"
+                if cn_short:
+                    display += f" ({cn_short})"
+                items.append(display)
+            result[artist] = items
+        return result
+
     def search_artists_pipeline(
         self,
         query: str,
@@ -1413,18 +1445,66 @@ class DanbooruTagger:
         print(f'[Engine] 加载标签-画师共现表 ({path.name})...')
         t0 = time.time()
         try:
+            import math
             df = pd.read_parquet(str(path))
+
+            # 预计算语料库总大小和 tag → post_count 映射
+            total_posts = float(max(self.df['post_count'].max(), 7_000_000))
+            tag_post_count = dict(zip(self.df['name'], self.df['post_count']))
+
             index: dict[str, list[tuple]] = {}
+            skipped = 0
             for _, row in df.iterrows():
                 tag = str(row["tag"])
+                artist = str(row["artist"])
+                cooc = int(row["cooc_count"])
+                artist_pc = int(row["artist_post_count"])
+
+                # 获取标签的 post_count
+                tag_pc = tag_post_count.get(tag)
+                if tag_pc is None or tag_pc <= 0:
+                    skipped += 1
+                    continue
+
+                # 即时计算 NPMI（与 get_related 相同算法）
+                cooc_capped = min(float(cooc), float(tag_pc), float(artist_pc))
+                if cooc_capped <= 0:
+                    skipped += 1
+                    continue
+
+                numerator = (cooc_capped * total_posts) / (float(tag_pc) * float(artist_pc))
+                if numerator <= 1.0:
+                    skipped += 1
+                    continue
+
+                pmi = math.log(numerator)
+                p_ab = cooc_capped / total_posts
+                if p_ab >= 1.0:
+                    npmi_val = 1.0
+                else:
+                    npmi_val = pmi / -math.log(p_ab)
+
+                if math.isnan(npmi_val):
+                    skipped += 1
+                    continue
+
                 index.setdefault(tag, []).append(
-                    (str(row["artist"]), float(row["npmi"]),
-                     int(row["cooc_count"]), int(row["artist_post_count"]))
-                )
+                    (artist, npmi_val, cooc, artist_pc))
+
             self._tag_artist_index = index
+
+            # 构建反向索引：artist → top tags（按 NPMI 降序）
+            artist_tags: dict[str, list[tuple]] = {}
+            for tag, entries in index.items():
+                for artist, npmi, cooc, _ in entries:
+                    artist_tags.setdefault(artist, []).append((tag, npmi, cooc))
+            for artist, entries in artist_tags.items():
+                entries.sort(key=lambda x: -x[1])
+            self._artist_top_tags = artist_tags
+
             print(
                 f'[Engine] 标签-画师共现表加载完成，{len(index):,} 个标签，'
-                f'耗时 {time.time() - t0:.2f}s'
+                f'跳过 {skipped:,} 行，耗时 {time.time() - t0:.2f}s'
             )
         except Exception as e:
             print(f'[Engine] 标签-画师共现表加载失败: {e}')

mcp_server.py

@@ -329,6 +329,119 @@ JSON array sorted by aggregated NPMI score (descending). Each result:
     return json.dumps(payload, ensure_ascii=False, indent=2)
 
 
+@mcp.tool()
+async def get_artist_recommendations(
+    tags: list[str],
+    limit: int = 30,
+    min_cooc: int = 3,
+    show_nsfw: bool = True,
+) -> str:
+    """
+    Recommend artists who are skilled at drawing the given tags, based on NPMI co-occurrence data.
+
+    Given a list of Danbooru tags (e.g. character names, clothing, styles), this tool returns
+    artists whose works frequently co-occur with those tags on Danbooru, ranked by aggregated
+    NPMI score.
+
+    ## Args
+    - tags: List of canonical Danbooru tag names (underscores, no spaces).
+            e.g. ["1girl", "blue_hair", "school_uniform"]
+    - limit: Max artists returned. Default 30.
+    - min_cooc: Minimum co-occurrence count per (tag, artist) pair to consider. Default 3.
+    - show_nsfw: Include NSFW artist data. Default True.
+
+    ## Returns
+
+    JSON array sorted by NPMI score (descending). Each result:
+    - artist: Danbooru artist tag name
+    - score: Aggregated NPMI score (higher = stronger association)
+    - cooc_count: Total co-occurrence count across all input tags
+    - post_count: Artist's total post count on Danbooru
+    - sources: Input tags that matched this artist
+    - hit_count: Number of input tags that matched
+    """
+    tagger = await DanbooruTagger.get_instance()
+
+    if not tags:
+        return json.dumps({"error": "tags 列表不能为空"}, ensure_ascii=False, indent=2)
+
+    # ── 检查标签是否存在，不存在则尝试 search_tags 纠错 ──────────────────
+    valid_tags = []
+    invalid_tags = []
+    for t in tags:
+        if t in tagger._name_to_idx:
+            valid_tags.append(t)
+        else:
+            invalid_tags.append(t)
+
+    corrections = {}
+    if invalid_tags:
+        for bad_tag in invalid_tags:
+            try:
+                req = SearchRequest(
+                    query=bad_tag,
+                    top_k=5,
+                    limit=5,
+                    popularity_weight=0.15,
+                    use_segmentation=False,
+                    target_layers=['英文']
+                )
+                resp = await tagger.search_async(req)
+                if resp.results:
+                    corrections[bad_tag] = resp.results[0].tag
+            except Exception:
+                pass
+
+    if not valid_tags and not corrections:
+        return json.dumps({
+            "error": "所有传入的标签均不存在于标签表中",
+            "invalid_tags": invalid_tags,
+        }, ensure_ascii=False, indent=2)
+
+    # 用纠错后的标签替换无效标签
+    corrected_tags = []
+    for t in tags:
+        if t in valid_tags:
+            corrected_tags.append(t)
+        elif t in corrections:
+            corrected_tags.append(corrections[t])
+
+    results = await tagger.search_artists_by_tags_async(
+        corrected_tags, limit=limit, min_cooc=min_cooc,
+    )
+
+    output = []
+    for r in results:
+        item = {
+            "artist":     r.artist,
+            "score":      round(r.score, 4),
+            "cooc_count": r.cooc_count,
+            "post_count": r.post_count,
+            "sources":    r.sources,
+            "hit_count":  r.hit_count,
+        }
+        output.append(item)
+
+    # 计数
+    await counter.increment()
+    await counter.increment_success()
+    await counter.increment_copy()
+    await counter.increment_mcp()
+
+    payload = {"results": output}
+    if corrections:
+        correction_notes = [
+            f"{bad} → {good}" for bad, good in corrections.items()
+        ]
+        payload = {
+            "correction_note": "标签拼写错误，已经纠错: " + ", ".join(correction_notes),
+            "corrections": corrections,
+            "results": output,
+        }
+
+    return json.dumps(payload, ensure_ascii=False, indent=2)
+
+
 # ── Anima 提示词格式说明 ─────────────────────────────────────────────────
 _ANIMA_FORMAT_INSTRUCTION = """请严格按以下 Anima 混合提示词（Hybrid Prompt）规范，基于提供的标签和用户描述，输出最终结果。
 

platform_utils.py

@@ -294,7 +294,7 @@ def download_file(
 
 #  模型路径解析 
 
-LOCAL_MODEL_PATH = 'my_model_bge_m3'
+LOCAL_MODEL_PATH = 'D:/LLMs/BAAI/bge-m3'
 HF_MODEL_ID      = 'BAAI/bge-m3'
 MS_MODEL_ID      = 'BAAI/bge-m3'   # 魔搭上同名，走国内节点
 

ui_nicegui.py

@@ -86,7 +86,7 @@ OPTIONAL_COLS = {
 
 # localStorage key 与配置版本，版本变更时自动丢弃旧配置
 _CONFIG_LS_KEY = 'danbooru_search_config'
-_CONFIG_VERSION = 5
+_CONFIG_VERSION = 6
 
 # 搜索模式预设
 _SEARCH_MODE_PRESETS: dict[str, dict] = {
@@ -170,6 +170,7 @@ class DanbooruSearchUI:
         # 去抖任务句柄（取消旧任务避免 CPU 洪峰）
         self._debounce_related_task = None  # type: asyncio.Task | None
         self._debounce_group_task = None    # type: asyncio.Task | None
+        self._debounce_artist_task = None   # type: asyncio.Task | None
 
         # tag -> prompt 权重，范围 [0.1, 1.9]，默认 1.0
         self.tag_weights: dict[str, float] = {}
@@ -177,12 +178,6 @@ class DanbooruSearchUI:
         self.prompt_format: str = 'sdxl'
         self.format_toggle_btn = None
 
-        # 画师查找模式
-        self.artist_search_mode: bool = False
-        self.artist_search_btn = None
-        self.artist_results_container = None
-        self.current_artist_seed_tags: list[str] = []  # 本次画师搜索使用的种子标签
-
         self.init_banner = None
         self.input_top_k = None
         self.input_limit = None
@@ -215,6 +210,10 @@ class DanbooruSearchUI:
         self._related_checkboxes: dict[str, ui.checkbox] = {}
         # 同类标签的 checkbox 引用
         self._group_checkboxes: dict[str, ui.checkbox] = {}
+        # 推荐画师的 checkbox 引用
+        self._artist_rec_checkboxes: dict[str, ui.checkbox] = {}
+        # 当前推荐画师的标签名集合（用于 Anima 模式复制时加 @ 前缀）
+        self._current_artist_rec_tags: set[str] = set()
 
         # 高级选项中各层/类型的 checkbox 引用，用于 restore 时同步控件状态
         self._layer_checkboxes: dict[str, ui.checkbox] = {}
@@ -298,7 +297,6 @@ class DanbooruSearchUI:
             'search_mode': self.input_search_mode.value if self.input_search_mode else '自定义',
             'group_mode': self.input_group_mode.value if self.input_group_mode else 'off',
             'max_per_group': int(self.input_max_per_group.value) if self.input_max_per_group else 2,
-            'artist_search_mode': self.artist_search_mode,
         }
         js = _json.dumps(cfg, ensure_ascii=False)
         ui.run_javascript(f"localStorage.setItem('{_CONFIG_LS_KEY}', {_json.dumps(js)});")
@@ -395,10 +393,6 @@ class DanbooruSearchUI:
         if self.mcp_notice and cfg.get('mcp_notice_dismissed'):
             self.mcp_notice.set_visibility(False)
 
-        # 恢复画师查找模式
-        if cfg.get('artist_search_mode'):
-            self._on_search_type_change(True)
-
         # 若高级选项列有变更，同步更新表格列
         self._update_table_columns()
 
@@ -469,59 +463,6 @@ class DanbooruSearchUI:
                     }
                 }
 
-                /* 画师查找模式 — 暗色主题 */
-                body[data-search-mode="artist"] .artist-card-row {
-                    background: rgba(245, 158, 11, 0.06);
-                    border-color: rgba(245, 158, 11, 0.15);
-                }
-                .artist-card-row {
-                    transition: background-color 0.2s, border-color 0.2s;
-                }
-                .artist-card-row:hover {
-                    background: rgba(245, 158, 11, 0.12) !important;
-                }
-                .mode-toggle-btn {
-                    transition: all 0.25s ease;
-                }
-
-                /* 暗色模式下文字颜色覆盖 */
-                body[data-search-mode="artist"] .text-gray-800,
-                body[data-search-mode="artist"] .text-gray-700,
-                body[data-search-mode="artist"] .text-gray-600 {
-                    color: #cbd5e1 !important;
-                }
-                body[data-search-mode="artist"] .text-gray-500 {
-                    color: #94a3b8 !important;
-                }
-                body[data-search-mode="artist"] .text-gray-400 {
-                    color: #64748b !important;
-                }
-
-                /* 暗色模式下公告栏 / 注意事项卡片适配 */
-                body[data-search-mode="artist"] .bg-green-50 {
-                    background: rgba(16, 185, 129, 0.1) !important;
-                    border-color: rgba(16, 185, 129, 0.3) !important;
-                }
-                body[data-search-mode="artist"] .text-green-800,
-                body[data-search-mode="artist"] .text-green-900,
-                body[data-search-mode="artist"] .text-green-700 {
-                    color: #6ee7b7 !important;
-                }
-                body[data-search-mode="artist"] .bg-orange-50 {
-                    background: rgba(249, 115, 22, 0.1) !important;
-                    border-color: rgba(249, 115, 22, 0.3) !important;
-                }
-                body[data-search-mode="artist"] .text-orange-800 {
-                    color: #fdba74 !important;
-                }
-                body[data-search-mode="artist"] .bg-blue-50 {
-                    background: rgba(59, 130, 246, 0.1) !important;
-                    border-color: rgba(59, 130, 246, 0.3) !important;
-                }
-                body[data-search-mode="artist"] .text-blue-700,
-                body[data-search-mode="artist"] .text-blue-600 {
-                    color: #93c5fd !important;
-                }
             </style>
             <script async src="https://www.googletagmanager.com/gtag/js?id=G-QPB7EEPR5G"></script>
             <script>
@@ -595,11 +536,7 @@ class DanbooruSearchUI:
                 # ── 4. 分词筛选 chips ──
                 self.keywords_container = ui.row().classes('gap-2 items-center flex-wrap')
 
-                # ── 5. 画师结果容器（画师模式专用）──
-                self.artist_results_container = ui.column().classes('w-full gap-3')
-                self.artist_results_container.set_visibility(False)
-
-                # ── 6. 两栏结果（标签模式）──
+                # ── 5. 两栏结果 ──
                 self._build_results_columns()
 
             # ── 6. 底部 ──
@@ -607,7 +544,7 @@ class DanbooruSearchUI:
                 self.search_count_label = ui.html('正在加载数据...').classes('text-xs text-gray-400')
                 self._update_footer_text()
 
-    # ── 公告栏（画师查找 + 标签组 + MCP）───────────────────────────────────
+    # ── 公告栏（标签组 + MCP）─────────────────────────────────────────────
 
     def _build_group_notice(self):
         self.mcp_notice = ui.card().classes(
@@ -618,12 +555,12 @@ class DanbooruSearchUI:
                 # ── 画师查找公告 ──
                 with ui.row().classes('items-center justify-between w-full'):
                     with ui.row().classes('items-center gap-1'):
-                        ui.label('🧪 新功能：画师查找（beta）').classes('text-sm font-bold text-green-800')
+                        ui.label('🧪 新功能：推荐擅长画师（beta）').classes('text-sm font-bold text-green-800')
                     ui.button(icon='close').props('flat dense round color=grey-6') \
                         .on_click(self._dismiss_mcp_notice)
                 ui.html(
-                    '基于标签共现数据，输入风格描述即可查找对应画师。'
-                    '点击搜索栏上方的 <b>「画师查找（beta）」</b> 按钮即可切换模式。'
+                    '基于标签共现数据，根据已选标签查找对应的擅长画师。'
+                    '鼠标悬停画师行可查看该画师最常画的标签'
                 ).classes('text-xs text-green-900')
                 ui.separator().classes('my-1')
                 # ── 标签组扩展 ──
@@ -681,18 +618,10 @@ class DanbooruSearchUI:
 
     def _build_search_card(self):
         with ui.card().classes('w-full'):
-            # ── 模式切换按钮 ──
-            with ui.row().classes('w-full items-center justify-between mb-3'):
-                with ui.row().classes('items-center gap-0'):
-                    self.tag_mode_btn = ui.button('标签搜索', on_click=lambda: self._on_search_type_change(False)) \
-                        .props('unelevated color=primary').classes('mode-toggle-btn rounded-r-none')
-                    self.artist_mode_btn = ui.button('画师查找（beta）', on_click=lambda: self._on_search_type_change(True)) \
-                        .props('flat color=grey-6').classes('mode-toggle-btn rounded-l-none')
-
             with ui.row().classes('items-center gap-2 mb-2'):
                 ui.icon('search', size='2em', color='primary')
-                self.search_title_label = ui.label('Danbooru 标签模糊搜索').classes('text-2xl font-bold text-gray-800')
-            self.search_subtitle_label = ui.label(
+                ui.label('Danbooru 标签模糊搜索').classes('text-2xl font-bold text-gray-800')
+            ui.label(
                 '基于语义匹配的标签搜索引擎，支持多维匹配与共现关联推荐。'
             ).classes('text-sm text-gray-500 -mt-1 mb-3')
 
@@ -775,7 +704,7 @@ class DanbooruSearchUI:
 
                         with ui.column().classes('gap-2'):
                             ui.label('类型筛选').classes('font-bold text-sm text-gray-700')
-                            color_map = {'General': 'blue', 'Copyright': 'pink', 'Character': 'green'}
+                            color_map = {'General': 'blue', 'Copyright': 'purple', 'Character': 'green'}
                             label_map = {
                                 'General': '通用 (General)',
                                 'Copyright': '作品 (Copyright)',
@@ -984,11 +913,14 @@ class DanbooruSearchUI:
         self.tag_weights.clear()
         if self.result_table is not None:
             self.result_table.selected = []
+        self._artist_rec_checkboxes.clear()
+        self._current_artist_rec_tags.clear()
         self._render_selected_chips()
         if self.selection_count_label is not None:
             self.selection_count_label.text = '0'
         show_nsfw_val = self.input_nsfw.value
         self._refresh_related([], show_nsfw_val)
+        self._render_artist_rec([], {})
         # 清空 Group 同类扩展
         if self.group_expansion_container is not None:
             self.group_expansion_container.clear()
@@ -1028,7 +960,7 @@ class DanbooruSearchUI:
                               'background-color':
                                   props.row.category === 'General'   ? 'rgba(59,130,246,0.06)' :
                                   props.row.category === 'Character' ? 'rgba(34,197,94,0.06)'  :
-                                  props.row.category === 'Copyright' ? 'rgba(236,72,153,0.06)' : ''
+                                  props.row.category === 'Copyright' ? 'rgba(168,85,247,0.06)' : ''
                           }">
                         <q-td auto-width>
                             <q-checkbox v-model="props.selected"
@@ -1096,8 +1028,25 @@ class DanbooruSearchUI:
                 with self.group_expansion_container:
                     ui.label('请先搜索并勾选标签…').classes('text-sm text-gray-400 italic p-4')
 
-            # ── 右栏：关联推荐 ──
+            # ── 右栏：推荐画师 + 关联推荐 ──
             with ui.card().classes('col-right'):
+                # 推荐画师
+                with ui.row().classes('items-center justify-between w-full mb-2'):
+                    with ui.row().classes('items-center gap-2'):
+                        ui.label('推荐擅长画师(Beta)').classes('font-bold text-lg text-gray-800')
+                        with ui.icon('info_outline', size='sm', color='grey').classes('cursor-help'):
+                            with ui.tooltip().props('content-class="bg-black text-white shadow-4"'):
+                                ui.html(
+                                    '基于标签-画师 NPMI 共现数据，根据您当前已选的标签，推荐擅长这些元素的画师。<br>悬停画师行可查看与该画师共现关联最强的标签。').style(
+                                    'font-size:14px;line-height:1.5;')
+
+                self.artist_rec_list = ui.column().classes('w-full gap-0').style('max-height: 420px; overflow-y: auto;')
+                with self.artist_rec_list:
+                    ui.label('请先搜索并勾选标签…').classes('text-sm text-gray-400 italic p-4')
+
+                ui.separator().classes('my-3')
+
+                # 关联推荐
                 with ui.row().classes('items-center justify-between w-full mb-2'):
                     with ui.row().classes('items-center gap-2'):
                         ui.label('关联推荐').classes('font-bold text-lg text-gray-800')
@@ -1115,73 +1064,6 @@ class DanbooruSearchUI:
                 with self.related_list_container:
                     ui.label('请先搜索并勾选标签…').classes('text-sm text-gray-400 italic p-4')
 
-    # ══════════════════════════════════════════════════════════════════════
-    # 渲染画师搜索结果
-    # ══════════════════════════════════════════════════════════════════════
-
-    async def _silent_increment_counter(self):
-        try:
-            await counter.increment()
-            self._update_footer_text()
-        except Exception:
-            pass
-
-    def _render_artist_results(self, artist_results, found_tags, missing_tags):
-        if self.artist_results_container is None:
-            return
-        self.artist_results_container.clear()
-
-        if not artist_results:
-            with self.artist_results_container:
-                with ui.card().classes('w-full bg-amber-50 border border-amber-200'):
-                    with ui.row().classes('items-center gap-2 p-4'):
-                        ui.icon('info', color='amber')
-                        ui.label('未找到匹配的画师，请尝试更具体的风格描述。').classes('text-sm text-amber-700')
-            return
-
-        max_score = max(r.score for r in artist_results) if artist_results else 1.0
-
-        with self.artist_results_container:
-            # 种子标签信息
-            if found_tags:
-                tags_display = ', '.join(found_tags)
-                ui.label(f'种子标签: {tags_display}').classes('text-sm text-gray-500 mb-1')
-            if missing_tags:
-                ui.label(f'未匹配画师的标签: {", ".join(missing_tags)}').classes('text-xs text-orange-400')
-
-            with ui.card().classes('w-full p-0'):
-                for i, r in enumerate(artist_results):
-                    pct = min(r.score / max_score * 100, 100) if max_score > 0 else 0
-                    rank = i + 1
-                    sources_str = ', '.join(r.sources[:5])
-                    post_str = f'{r.post_count:,}' if r.post_count else '—'
-
-                    with ui.row().classes(
-                        'w-full items-center gap-3 px-4 py-3 border-b border-gray-200 artist-card-row'
-                    ).style('border-bottom: 1px solid rgba(128,128,128,0.1);'):
-                        # 排名
-                        ui.label(f'#{rank}').classes(
-                            'text-lg font-bold min-w-[42px] text-center'
-                        ).style(f'color: {"#F59E0B" if rank <= 3 else "#9CA3AF"};')
-
-                        # 画师信息
-                        with ui.column().classes('flex-grow gap-0 min-w-0'):
-                            ui.link(r.artist, f'https://danbooru.donmai.us/posts?tags={r.artist}', new_tab=True) \
-                                .classes('text-base font-bold')
-                            with ui.row().classes('items-center gap-4 mt-1'):
-                                ui.label(f'匹配标签: {sources_str}').classes('text-xs text-gray-500')
-                                ui.label(f'Danbooru 作品: {post_str}').classes('text-xs text-gray-400')
-
-                        # 分数条
-                        with ui.column().classes('items-end gap-0 min-w-[80px]'):
-                            ui.label(f'{r.score:.4f}').classes('text-sm font-mono font-bold')
-                            with ui.element('div').classes('w-full h-2 rounded-full overflow-hidden') \
-                                    .style('background: rgba(128,128,128,0.15);'):
-                                ui.element('div').classes('h-full rounded-full').style(
-                                    f'width: {pct:.0f}%;'
-                                    f'background: #F59E0B;'
-                                )
-
     # ══════════════════════════════════════════════════════════════════════
     # 渲染关联推荐列表
     # ══════════════════════════════════════════════════════════════════════
@@ -1236,7 +1118,7 @@ class DanbooruSearchUI:
                 CAT_BG = {
                     'General':   'background-color: rgba(59,130,246,0.06);',   # 淡蓝
                     'Character': 'background-color: rgba(34,197,94,0.06);',    # 淡绿
-                    'Copyright': 'background-color: rgba(236,72,153,0.06);',   # 淡红/粉
+                    'Copyright': 'background-color: rgba(168,85,247,0.06);',   # 淡紫
                 }
                 row_bg = CAT_BG.get(r.category, '')
 
@@ -1323,52 +1205,6 @@ class DanbooruSearchUI:
                     chip_color, text_color = 'grey-4', 'black'
                 child.props(f'color={chip_color} text-color={text_color}')
 
-    # ── 搜索模式切换 ──────────────────────────────────────────────────────
-
-    def _on_search_type_change(self, artist_mode: bool):
-        if artist_mode == self.artist_search_mode:
-            return
-        self.artist_search_mode = artist_mode
-
-        if artist_mode:
-            # 画师查找 → 暗色主题
-            ui.colors(primary='#F59E0B', secondary='#78716C', accent='#10B981')
-            ui.dark_mode().enable()
-            self.tag_mode_btn.props('flat color=grey-6')
-            self.artist_mode_btn.props('unelevated color=primary')
-            self.search_title_label.set_text('画师查找')
-            self.search_subtitle_label.set_text('输入任何元素（如"平涂" "枪" "蔚蓝档案"），自动匹配擅长的画师。')
-            self.search_input.props('placeholder="输入任何元素，如：平涂 枪 蔚蓝档案..."')
-            # 隐藏搜索参数控件
-            self.search_params_row.set_visibility(False)
-            self.advanced_options.set_visibility(False)
-            # 清空旧结果并隐藏标签搜索专属区域
-            if self.results_section:
-                self.results_section.set_visibility(False)
-            if self.artist_results_container:
-                self.artist_results_container.clear()
-        else:
-            # 标签搜索 → 亮色主题
-            ui.colors(primary='#4A90E2', secondary='#5E6C84', accent='#FF6B6B')
-            ui.dark_mode().disable()
-            self.tag_mode_btn.props('unelevated color=primary')
-            self.artist_mode_btn.props('flat color=grey-6')
-            self.search_title_label.set_text('Danbooru 标签模糊搜索')
-            self.search_subtitle_label.set_text('基于语义匹配的标签搜索引擎，支持多维匹配与共现关联推荐。')
-            self.search_input.props('placeholder="输入自然语言描述或模糊概念，例如：一个穿着白色水手服的少女在雨中奔跑..."')
-            # 恢复搜索参数控件
-            self.search_params_row.set_visibility(True)
-            self.advanced_options.set_visibility(True)
-            # 清空旧结果
-            if self.results_section:
-                self.results_section.set_visibility(False)
-            if self.artist_results_container:
-                self.artist_results_container.clear()
-            self.keywords_container.clear()
-
-        ui.run_javascript(f"document.body.setAttribute('data-search-mode', '{'artist' if artist_mode else 'tag'}');")
-        self._save_config()
-
     # ── 搜索 ──────────────────────────────────────────────────────────────
 
     async def perform_search(self):
@@ -1411,134 +1247,92 @@ class DanbooruSearchUI:
         try:
             tagger = await DanbooruTagger.get_instance()
 
-            if self.artist_search_mode:
-                # ── 画师查找模式 ──
-                artist_results, seed_tags, found_tags, missing_tags = \
-                    await tagger.search_artists_pipeline_async(
-                        query,
-                        limit=30,
-                        target_layers=target_layers_list,
-                        target_categories=target_cats_list,
-                    )
+            show_nsfw_val = self.input_nsfw.value
+
+            request = SearchRequest(
+                query=query,
+                top_k=int(self.input_top_k.value),
+                limit=int(self.input_limit.value),
+                popularity_weight=float(self.input_weight.value),
+                show_nsfw=show_nsfw_val,
+                use_segmentation=self.input_segment.value if self.input_segment else True,
+                target_layers=target_layers_list,
+                target_categories=target_cats_list,
+                group_mode=self.input_group_mode.value if self.input_group_mode else 'off',
+                max_per_group=int(self.input_max_per_group.value) if self.input_max_per_group else 2,
+            )
+            response = await tagger.search_async(request)
+
+            # 后台计数
+            async def silent_counter_update():
+                try:
+                    await counter.increment()
+                    if response.keywords:
+                        await counter.add_keywords(response.keywords)
+                    self._update_footer_text()
+                except Exception as e:
+                    print(f"[UI] 后台静默更新计数失败: {e}", flush=True)
+            asyncio.create_task(silent_counter_update())
+
+            if not self._client_alive():
+                return
 
-                # 后台计数
-                asyncio.create_task(self._silent_increment_counter())
+            table_data = [result_to_row(r, show_nsfw_val) for r in response.results]
+            self.full_table_data = table_data
+            self.full_tags_str = response.tags_all
+            self.full_tags_str_sfw = response.tags_sfw
+            self.current_segments = list(response.segments) if response.segments else []
 
-                if not self._client_alive():
-                    return
+            self.results_section.set_visibility(True)
 
-                self.current_artist_seed_tags = seed_tags
-                self.results_section.set_visibility(True)
-                # 隐藏标签搜索专属区域
-                self.selection_bar_card.set_visibility(False)
-                self.two_col_container.set_visibility(False)
-                # 显示画师结果
-                self.artist_results_container.set_visibility(True)
+            _saved_rpp = self._get_rows_per_page()
+            self.result_table.rows = apply_nsfw_filter(table_data, show_nsfw_val)
+            self._set_rows_per_page(_saved_rpp)
+            all_selected = self._get_selected_tags()
+            self.chip_extra_selected.clear()
+            self.chip_extra_selected.update(all_selected)
+            self.result_table.selected = []
+            self._render_selected_chips()
+            self._update_selection_display(None)
+            self._save_staged_tags()
 
-                self.keywords_container.clear()
-                with self.keywords_container:
-                    ui.label('匹配种子标签:').classes('text-sm text-gray-500 font-bold mr-2')
-                    for tag in seed_tags:
-                        ui.chip(tag).props('color=amber-2 text-color=amber-9 clickable')
-                    if not seed_tags:
-                        ui.label('无').classes('text-xs text-gray-400 italic')
+            self._refresh_related([], show_nsfw_val)
 
-                self._render_artist_results(artist_results, found_tags, missing_tags)
-                ui.notify(f'找到 {len(artist_results)} 位画师', type='positive')
-                self.current_search_interacted = False
+            # 分词筛选 chips
+            self.current_filter_keyword = 'ALL'
+            self.keywords_container.clear()
+            cached_set = set(response.cached_queries) if response.cached_queries else set()
+            with self.keywords_container:
+                ui.label('分词筛选:').classes('text-sm text-gray-500 font-bold mr-2')
+                ui.chip('全部', on_click=lambda: self._filter_by_source('ALL')) \
+                    .props('color=primary text-color=white clickable')
+                use_seg = self.input_segment.value if self.input_segment else True
+                if use_seg:
+                    whole = ui.chip('整句',
+                            on_click=lambda: self._filter_by_source(self.current_query_str))
+                    whole.props('color=grey-4 text-color=black clickable')
+                    if self.current_query_str in cached_set:
+                        whole.style('outline: 1px dashed rgba(128,128,128,0.3); outline-offset: 1px;')
+                    for seg in response.segments:
+                        sc = ui.chip(seg,
+                                on_click=lambda s=seg: self._filter_by_source(s))
+                        sc.props('color=blue-1 text-color=blue-8 clickable')
+                        if seg in cached_set:
+                            sc.style('outline: 1px dashed rgba(128,128,128,0.3); outline-offset: 1px;')
+                    for kw in response.keywords:
+                        kc = ui.chip(kw,
+                                on_click=lambda k=kw: self._filter_by_source(k))
+                        kc.props('color=grey-4 text-color=black clickable')
+                        if kw in cached_set:
+                            kc.style('outline: 1px dashed rgba(128,128,128,0.3); outline-offset: 1px;')
+                else:
+                    ui.label('(分词已关闭)').classes('text-xs text-gray-400')
 
-            else:
-                # ── 标签搜索模式 ──
-                show_nsfw_val = self.input_nsfw.value
-
-                request = SearchRequest(
-                    query=query,
-                    top_k=int(self.input_top_k.value),
-                    limit=int(self.input_limit.value),
-                    popularity_weight=float(self.input_weight.value),
-                    show_nsfw=show_nsfw_val,
-                    use_segmentation=self.input_segment.value if self.input_segment else True,
-                    target_layers=target_layers_list,
-                    target_categories=target_cats_list,
-                    group_mode=self.input_group_mode.value if self.input_group_mode else 'off',
-                    max_per_group=int(self.input_max_per_group.value) if self.input_max_per_group else 2,
-                )
-                response = await tagger.search_async(request)
-
-                # 后台计数
-                async def silent_counter_update():
-                    try:
-                        await counter.increment()
-                        if response.keywords:
-                            await counter.add_keywords(response.keywords)
-                        self._update_footer_text()
-                    except Exception as e:
-                        print(f"[UI] 后台静默更新计数失败: {e}", flush=True)
-                asyncio.create_task(silent_counter_update())
-
-                if not self._client_alive():
-                    return
-
-                table_data = [result_to_row(r, show_nsfw_val) for r in response.results]
-                self.full_table_data = table_data
-                self.full_tags_str = response.tags_all
-                self.full_tags_str_sfw = response.tags_sfw
-                self.current_segments = list(response.segments) if response.segments else []
-
-                self.results_section.set_visibility(True)
-                # 显示标签搜索专属区域
-                self.selection_bar_card.set_visibility(True)
-                self.two_col_container.set_visibility(True)
-                self.artist_results_container.set_visibility(False)
-
-                _saved_rpp = self._get_rows_per_page()
-                self.result_table.rows = apply_nsfw_filter(table_data, show_nsfw_val)
-                self._set_rows_per_page(_saved_rpp)
-                all_selected = self._get_selected_tags()
-                self.chip_extra_selected.clear()
-                self.chip_extra_selected.update(all_selected)
-                self.result_table.selected = []
-                self._render_selected_chips()
-                self._update_selection_display(None)
-                self._save_staged_tags()
-
-                self._refresh_related([], show_nsfw_val)
-
-                # 分词筛选 chips
-                self.current_filter_keyword = 'ALL'
-                self.keywords_container.clear()
-                cached_set = set(response.cached_queries) if response.cached_queries else set()
-                with self.keywords_container:
-                    ui.label('分词筛选:').classes('text-sm text-gray-500 font-bold mr-2')
-                    ui.chip('全部', on_click=lambda: self._filter_by_source('ALL')) \
-                        .props('color=primary text-color=white clickable')
-                    use_seg = self.input_segment.value if self.input_segment else True
-                    if use_seg:
-                        whole = ui.chip('整句',
-                                on_click=lambda: self._filter_by_source(self.current_query_str))
-                        whole.props('color=grey-4 text-color=black clickable')
-                        if self.current_query_str in cached_set:
-                            whole.style('outline: 1px dashed rgba(128,128,128,0.3); outline-offset: 1px;')
-                        for seg in response.segments:
-                            sc = ui.chip(seg,
-                                    on_click=lambda s=seg: self._filter_by_source(s))
-                            sc.props('color=blue-1 text-color=blue-8 clickable')
-                            if seg in cached_set:
-                                sc.style('outline: 1px dashed rgba(128,128,128,0.3); outline-offset: 1px;')
-                        for kw in response.keywords:
-                            kc = ui.chip(kw,
-                                    on_click=lambda k=kw: self._filter_by_source(k))
-                            kc.props('color=grey-4 text-color=black clickable')
-                            if kw in cached_set:
-                                kc.style('outline: 1px dashed rgba(128,128,128,0.3); outline-offset: 1px;')
-                    else:
-                        ui.label('(分词已关闭)').classes('text-xs text-gray-400')
-
-                ui.notify(f'找到 {len(table_data)} 个标签', type='positive')
-                self.current_search_interacted = False
-
-                if self.bad_case_btn is not None:
-                    self.bad_case_btn.enable()
+            ui.notify(f'找到 {len(table_data)} 个标签', type='positive')
+            self.current_search_interacted = False
+
+            if self.bad_case_btn is not None:
+                self.bad_case_btn.enable()
 
         except RuntimeError as e:
             if 'deleted' in str(e).lower() or 'client' in str(e).lower():
@@ -1580,6 +1374,10 @@ class DanbooruSearchUI:
         if self.result_table is not None:
             self.result_table.selected = [row for row in self.result_table.rows if row.get('tag') in tag_set]
 
+        # 同步推荐画师 checkbox
+        for t, cb in self._artist_rec_checkboxes.items():
+            cb.set_value(t in tag_set)
+
         all_tags = self._get_selected_tags()
         if self.selection_count_label is not None:
             self.selection_count_label.text = str(len(all_tags))
@@ -1592,6 +1390,7 @@ class DanbooruSearchUI:
             show_nsfw_val = self.input_nsfw.value
             self._refresh_related_from_selection(all_tags, show_nsfw_val)
             self._refresh_group_from_selection(all_tags, show_nsfw_val)
+            self._refresh_artist_from_selection(all_tags, show_nsfw_val)
             if not all_tags:
                 self.chip_extra_selected.clear()
 
@@ -1614,9 +1413,14 @@ class DanbooruSearchUI:
             self.selection_count_label.text = str(len(all_tags))
         self._render_selected_chips()
 
+        # 同步推荐画师 checkbox
+        for t, cb in self._artist_rec_checkboxes.items():
+            cb.set_value(t in tag_set)
+
         show_nsfw_val = self.input_nsfw.value
         self._refresh_related_from_selection(all_tags, show_nsfw_val)
         self._refresh_group_from_selection(all_tags, show_nsfw_val)
+        self._refresh_artist_from_selection(all_tags, show_nsfw_val)
         if not all_tags:
             self.chip_extra_selected.clear()
         self._save_staged_tags()
@@ -1636,6 +1440,9 @@ class DanbooruSearchUI:
                 self.tag_weights.pop(tag, None)
                 self._set_selected_tags(current, skip_refresh=True)
                 ui.notify(f'已移除 {tag}', type='warning', timeout=1500)
+        # 刷新推荐画师
+        show_nsfw_val = self.input_nsfw.value
+        self._refresh_artist_from_selection(current, show_nsfw_val)
 
     def _on_group_checkbox_change(self, tag: str, checked: bool):
         """同类标签复选框变化回调。"""
@@ -1653,9 +1460,27 @@ class DanbooruSearchUI:
                 self.tag_weights.pop(tag, None)
                 self._set_selected_tags(current, skip_refresh=True)
                 ui.notify(f'已移除 {tag}', type='warning', timeout=1500)
-        # 即刻刷新关联推荐
+        # 即刻刷新关联推荐 + 画师推荐
         show_nsfw_val = self.input_nsfw.value
         self._refresh_related_from_selection(current, show_nsfw_val)
+        self._refresh_artist_from_selection(current, show_nsfw_val)
+
+    def _on_artist_rec_checkbox_change(self, tag: str, checked: bool):
+        """推荐画师复选框变化回调。"""
+        self._mark_interaction()
+        current = self._get_selected_tags()
+        if checked:
+            if tag not in current:
+                current.append(tag)
+                self.tag_weights.setdefault(tag, 1.0)
+                self._set_selected_tags(current, skip_refresh=True)
+                ui.notify(f'已添加画师 {tag}', type='positive', timeout=1500)
+        else:
+            if tag in current:
+                current.remove(tag)
+                self.tag_weights.pop(tag, None)
+                self._set_selected_tags(current, skip_refresh=True)
+                ui.notify(f'已移除画师 {tag}', type='warning', timeout=1500)
 
     def _manual_refresh_related(self):
         """手动触发关联推荐列表的刷新"""
@@ -1665,6 +1490,7 @@ class DanbooruSearchUI:
 
         if all_tags:
             self._refresh_related_from_selection(all_tags, show_nsfw_val)
+            self._refresh_artist_from_selection(all_tags, show_nsfw_val)
             ui.notify('已触发关联推荐更新', type='info', timeout=1500)
         else:
             self.chip_extra_selected.clear()
@@ -1742,6 +1568,90 @@ class DanbooruSearchUI:
             self._render_group_expansion(group_data, selected_tags, show_nsfw)
         self._debounce_group_task = asyncio.ensure_future(_do())
 
+    def _refresh_artist_from_selection(self, selected_tags: list[str], show_nsfw: bool = True):
+        """根据已选标签刷新画师推荐（300ms 去抖）。"""
+        if self._debounce_artist_task and not self._debounce_artist_task.done():
+            self._debounce_artist_task.cancel()
+        async def _do():
+            await asyncio.sleep(0.3)
+            if len(selected_tags) < 1:
+                self._render_artist_rec([], {}, show_nsfw)
+                return
+            tagger = await DanbooruTagger.get_instance()
+            artist_results = await tagger.search_artists_by_tags_async(
+                selected_tags, limit=30, min_cooc=3,
+            )
+            top_tags = {}
+            if artist_results:
+                names = [r.artist for r in artist_results[:10]]
+                top_tags = tagger.get_artist_top_tags(names, show_nsfw=show_nsfw)
+            self._render_artist_rec(artist_results, top_tags, show_nsfw)
+        self._debounce_artist_task = asyncio.ensure_future(_do())
+
+    def _render_artist_rec(self, artist_results, top_tags=None, show_nsfw: bool = True):
+        """渲染推荐画师列表（对标关联推荐样式）。"""
+        if self.artist_rec_list is None:
+            return
+        self.artist_rec_list.clear()
+        self._artist_rec_checkboxes.clear()
+        self._current_artist_rec_tags.clear()
+
+        if not artist_results:
+            with self.artist_rec_list:
+                ui.label('暂无推荐画师').classes('text-sm text-gray-400 italic p-4')
+            return
+
+        top_tags = top_tags or {}
+        selected_now = set(self._get_selected_tags())
+
+        with self.artist_rec_list:
+            for r in artist_results[:10]:
+                artist = r.artist
+                self._current_artist_rec_tags.add(artist)
+                is_selected = artist in selected_now
+                # 归一化：除以命中标签数，cap 到 100%
+                normalized = min(r.score / max(r.hit_count, 1), 1.0)
+                score_pct = f'+{normalized * 100:.0f}%'
+                sources_str = '、'.join(r.sources[:3]) if r.sources else '—'
+                post_str = f'{r.post_count:,}' if r.post_count else '—'
+
+                # tooltip：画师擅长标签
+                tag_list = top_tags.get(artist, [])
+                tooltip_html = f'<div><b>{artist}</b><br>这位画师经常画:<br>'
+                if tag_list:
+                    for t in tag_list[:10]:
+                        tooltip_html += f'  · {t}<br>'
+                else:
+                    tooltip_html += '  (无数据)'
+                tooltip_html += '</div>'
+
+                with ui.row().classes(
+                    'w-full items-center gap-2 px-3 py-2 related-item border-b border-gray-100'
+                ).style('background: rgba(244,114,182,0.04);'):
+                    # tooltip
+                    with ui.tooltip().props('content-class="bg-black text-white shadow-4" max-width="400px"'):
+                        ui.html(tooltip_html).style('font-size:14px;line-height:1.5;max-width:380px;')
+
+                    # Checkbox
+                    cb = ui.checkbox(
+                        '', value=is_selected,
+                        on_change=lambda e, t=artist: self._on_artist_rec_checkbox_change(t, e.value)
+                    ).props('dense')
+                    self._artist_rec_checkboxes[artist] = cb
+
+                    # 画师名 + 信息
+                    with ui.column().classes('flex-grow gap-0 min-w-0'):
+                        ui.link(
+                            artist,
+                            f'https://danbooru.donmai.us/posts?tags={artist}',
+                            new_tab=True,
+                        ).classes('text-primary font-bold text-xs')
+                        ui.label(f'{sources_str} · 作品 {post_str}').classes('text-xs text-gray-500')
+
+                    # 分值
+                    score_color = 'green' if normalized > 0.6 else ('teal' if normalized > 0.3 else 'grey')
+                    ui.label(score_pct).classes(f'text-sm font-bold text-{score_color}-600 whitespace-nowrap')
+
     def _render_group_expansion(self, group_data: list, selected_tags: list[str], show_nsfw: bool):
         """渲染 Group 同类扩展区域。"""
         if self.group_expansion_container is None:
@@ -1758,7 +1668,7 @@ class DanbooruSearchUI:
         CAT_BG = {
             'General':   'background-color: rgba(59,130,246,0.06);',
             'Character': 'background-color: rgba(34,197,94,0.06);',
-            'Copyright': 'background-color: rgba(236,72,153,0.06);',
+            'Copyright': 'background-color: rgba(168,85,247,0.06);',
         }
         CAT_LABEL = {'General': '通用', 'Character': '角色', 'Copyright': '作品'}
 
@@ -1902,10 +1812,14 @@ class DanbooruSearchUI:
     def copy_selection(self):
         self._mark_interaction()
         tags = self._get_selected_tags()
-        prompt = ', '.join(
-            _format_tag_with_weight(t, self.tag_weights.get(t, 1.0), self.prompt_format)
-            for t in tags
-        )
+        parts = []
+        for t in tags:
+            w = self.tag_weights.get(t, 1.0)
+            if self.prompt_format == 'anima' and t in self._current_artist_rec_tags:
+                parts.append(_format_tag_with_weight(f'@{t}', w, self.prompt_format))
+            else:
+                parts.append(_format_tag_with_weight(t, w, self.prompt_format))
+        prompt = ', '.join(parts)
         ui.clipboard.write(prompt)
         fmt_label = {'sdxl': 'SDXL', 'nai': 'NAI', 'anima': 'Anima'}.get(self.prompt_format, 'SDXL')
         ui.notify(f'已复制选中标签（{fmt_label} 格式）!', type='positive')