update

main.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+主入口脚本
+提供统一的命令行接口来运行特征搜索流程
+"""
+
+import sys
+import os
+
+# 将项目根目录添加到Python路径
+project_root = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, project_root)
+
+from src.pipeline.feature_search_pipeline import main
+
+if __name__ == '__main__':
+    main()

src/clients/openrouter_client.py

@@ -21,7 +21,7 @@ class OpenRouterClient:
     def __init__(
         self,
         api_key: Optional[str] = None,
-        model: str = "google/gemini-2.5-pro",
+        model: str = "google/gemini-2.5-flash",
         max_tokens: int = 8192,
         temperature: float = 0.3,
         retry_delay: int = 3

src/pipeline/feature_search_pipeline.py

@@ -57,7 +57,7 @@ class EnhancedSearchV2:
         deep_analysis_sort_by: str = 'score',
         deep_analysis_api_url: str = "http://192.168.245.150:7000/what/analysis/single",
         deep_analysis_min_score: float = 0.8,
-        enable_similarity_analysis: bool = False,
+        enable_similarity: bool = False,
         similarity_weight_embedding: float = 0.5,
         similarity_weight_semantic: float = 0.5,
         similarity_max_workers: int = 5,
@@ -86,7 +86,7 @@ class EnhancedSearchV2:
             deep_analysis_sort_by: 深度解构排序方式：score/time/engagement（默认score）
             deep_analysis_api_url: 深度解构API地址
             deep_analysis_min_score: 深度解构处理的最低分数阈值（默认0.8，0-1分制）
-            enable_similarity_analysis: 是否启用相似度分析（默认False）
+            enable_similarity: 是否启用相似度分析（默认False）
             similarity_weight_embedding: 相似度分析向量模型权重（默认0.5）
             similarity_weight_semantic: 相似度分析LLM模型权重（默认0.5）
             similarity_max_workers: 相似度分析并发数（默认5）
@@ -104,7 +104,7 @@ class EnhancedSearchV2:
         self.evaluation_max_notes_per_query = evaluation_max_notes_per_query
         self.enable_deep_analysis = enable_deep_analysis
         self.deep_analysis_only = deep_analysis_only
-        self.enable_similarity_analysis = enable_similarity_analysis
+        self.enable_similarity = enable_similarity
 
         # 创建输出目录
         os.makedirs(output_dir, exist_ok=True)
@@ -261,7 +261,7 @@ class EnhancedSearchV2:
                     '来源层级': level_name,
                     '权重': 1.0,  # 新格式没有权重字段，默认1.0
                     '所属点名称': item_name,
-                    '最高匹配信息': top3_match_info[0],  # 保留第1个用于Stage2
+                    '最高匹配信息': top3_match_info[0],  # 保留第1个用于候选词提取
                     'top3匹配信息': top3_match_info  # 新增字段
                 }
 
@@ -491,11 +491,11 @@ class EnhancedSearchV2:
         """
         步骤4：多词组合 + LLM评估
 
-        基于Stage1的基础词和Stage3的高相似度候选，
+        基于特征筛选的基础词和候选词提取的高相似度候选，
         生成所有2-N词组合，通过LLM评估选出Top10
 
         Args:
-            features_data: 阶段3的数据（包含高相似度候选）
+            features_data: 候选词提取阶段的数据（包含高相似度候选）
             max_workers: 并发评估的原始特征数（默认4）
             max_candidates: 参与组合的最大候选词数（默认20）
             max_combo_length: 最大组合词数（默认4，即基础词+3个候选）
@@ -558,9 +558,9 @@ class EnhancedSearchV2:
         改进: 每个base_word使用自己的候选词（而不是共享）
 
         Steps:
-        1. Get top3 base_words from Stage1's top3匹配信息
+        1. Get top3 base_words from 特征筛选's top3匹配信息
         2. For each base_word:
-           a. Get candidates from Stage3's 高相似度候选_按base_word
+           a. Get candidates from 候选词提取's 高相似度候选_按base_word
            b. Generate combinations
            c. LLM evaluation
            d. Select Top 10
@@ -1045,7 +1045,7 @@ class EnhancedSearchV2:
                 final_results = evaluation_results
 
             # 相似度分析 - 条件执行
-            if self.enable_similarity_analysis and self.enable_deep_analysis:
+            if self.enable_similarity and self.enable_deep_analysis:
                 logger.info("\n" + "=" * 60)
                 logger.info("步骤7：相似度分析（解构特征与原始特征）")
                 logger.info("=" * 60)
@@ -1061,7 +1061,7 @@ class EnhancedSearchV2:
                 logger.info("=" * 60)
 
             logger.info("\n" + "=" * 60)
-            if self.enable_similarity_analysis and self.enable_deep_analysis:
+            if self.enable_similarity and self.enable_deep_analysis:
                 logger.info("✓ 完整流程执行完成（完整流程+深度分析+相似度分析）")
             elif self.enable_deep_analysis:
                 logger.info("✓ 完整流程执行完成（完整流程+深度分析）")
@@ -1107,7 +1107,38 @@ class EnhancedSearchV2:
 
 def main():
     """主函数"""
-    parser = argparse.ArgumentParser(description='增强搜索系统V2')
+    parser = argparse.ArgumentParser(
+        description='增强搜索系统V2',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog='''
+运行模式示例:
+  基础模式（仅搜索）:
+    python3 main.py --mode basic
+
+  标准模式（搜索+评估，推荐）:
+    python3 main.py --mode standard
+    python3 main.py  # 默认就是standard
+
+  完整模式（搜索+评估+解构+相似度）:
+    python3 main.py --mode full
+
+  自定义控制:
+    python3 main.py --enable-evaluation --enable-deep-analysis --deep-analysis-min-score 0.7
+        '''
+    )
+
+    # 运行模式预设
+    parser.add_argument(
+        '--mode',
+        choices=['basic', 'standard', 'full'],
+        default='standard',
+        help='''运行模式预设:
+        basic - 仅执行搜索（步骤1-4）
+        standard - 搜索+评估（步骤1-5，默认）
+        full - 完整流程（步骤1-7：搜索+评估+解构+相似度）
+        注: 具体的功能开关参数会覆盖mode设置'''
+    )
+
     parser.add_argument(
         '--how-json',
         default='input/posts/690d977d0000000007036331_how.json',
@@ -1154,101 +1185,139 @@ def main():
         help='每个base_word的最大搜索次数（默认None不限制）'
     )
     parser.add_argument(
-        '--enable-stage5',
+        '--enable-evaluation',
         action='store_true',
-        help='启用结果评估（默认False）'
+        help='启用搜索结果评估（默认False）'
     )
     parser.add_argument(
-        '--stage5-max-workers',
+        '--evaluation-max-workers',
         type=int,
         default=10,
-        help='结果评估并发评估数（默认10）'
+        help='结果评估并发数（默认10）'
     )
     parser.add_argument(
-        '--stage5-max-notes',
+        '--evaluation-max-notes',
         type=int,
         default=20,
-        help='每个搜索结果评估的最大帖子数（默认20）'
+        help='每个搜索词评估的最大帖子数（默认20）'
     )
     parser.add_argument(
-        '--enable-stage6',
+        '--enable-deep-analysis',
         action='store_true',
-        help='启用 深度解构分析'
+        help='启用帖子深度解构分析'
     )
     parser.add_argument(
-        '--stage6-only',
+        '--deep-analysis-only',
         action='store_true',
-        help='只运行 深度解构（从 结果评估 结果开始）'
+        help='仅运行深度解构（从已有评估结果开始）'
     )
     parser.add_argument(
-        '--stage6-max-workers',
+        '--deep-analysis-max-workers',
         type=int,
         default=5,
-        help='深度解构 并发数（默认5）'
+        help='深度解构并发数（默认5）'
     )
     parser.add_argument(
-        '--stage6-max-notes',
+        '--deep-analysis-max-notes',
         type=int,
         default=None,
-        help='深度解构 最多处理多少个完全匹配的帖子（默认None不限制）'
+        help='深度解构最多处理帖子数（默认None不限制）'
     )
     parser.add_argument(
-        '--stage6-skip',
+        '--deep-analysis-skip',
         type=int,
         default=0,
-        help='深度解构 跳过前 N 个完全匹配的帖子（默认0）'
+        help='深度解构跳过前N个帖子（默认0）'
     )
     parser.add_argument(
-        '--stage6-sort-by',
+        '--deep-analysis-sort-by',
         type=str,
         choices=['score', 'time', 'engagement'],
         default='score',
-        help='深度解构 排序方式: score(评分), time(时间), engagement(互动量)'
+        help='深度解构排序方式: score(评分), time(时间), engagement(互动量)'
     )
     parser.add_argument(
-        '--stage6-api-url',
+        '--deep-analysis-api-url',
         type=str,
         default='http://192.168.245.150:7000/what/analysis/single',
-        help='深度解构 解构 API 地址'
+        help='深度解构API地址'
     )
     parser.add_argument(
-        '--stage6-min-score',
+        '--deep-analysis-min-score',
         type=float,
         default=0.8,
-        help='深度解构 处理的最低分数阈值（默认0.8，0-1分制）'
+        help='深度解构处理的最低分数阈值（默认0.8，0-1分制）'
     )
     parser.add_argument(
-        '--enable-stage8',
+        '--enable-similarity',
         action='store_true',
-        help='启用相似度分析（默认False，需要先启用stage6）'
+        help='启用相似度分析（默认False，需要先启用深度解构）'
     )
     parser.add_argument(
-        '--stage8-weight-embedding',
+        '--similarity-weight-embedding',
         type=float,
         default=0.5,
         help='相似度分析向量模型权重（默认0.5）'
     )
     parser.add_argument(
-        '--stage8-weight-semantic',
+        '--similarity-weight-semantic',
         type=float,
         default=0.5,
-        help='相似度分析LLM模型权重（默认0.5）'
+        help='相似度分析语义模型权重（默认0.5）'
     )
     parser.add_argument(
-        '--stage8-max-workers',
+        '--similarity-max-workers',
         type=int,
         default=5,
         help='相似度分析并发数（默认5）'
     )
     parser.add_argument(
-        '--stage8-min-similarity',
+        '--similarity-min-threshold',
         type=float,
         default=0.0,
-        help='相似度分析最小相似度阈值（默认0.0）'
+        help='相似度分析最小阈值（默认0.0保留所有）'
     )
 
     args = parser.parse_args()
 
+    # 根据mode参数设置默认的功能启用状态
+    mode_presets = {
+        'basic': {
+            'enable_evaluation': False,
+            'enable_deep_analysis': False,
+            'enable_similarity': False
+        },
+        'standard': {
+            'enable_evaluation': True,
+            'enable_deep_analysis': False,
+            'enable_similarity': False
+        },
+        'full': {
+            'enable_evaluation': True,
+            'enable_deep_analysis': True,
+            'enable_similarity': True
+        }
+    }
+
+    # 获取mode对应的预设
+    mode_config = mode_presets.get(args.mode, mode_presets['standard'])
+
+    # 应用mode预设（具体的功能开关参数会覆盖mode设置）
+    # 如果用户明确指定了功能开关，则使用用户指定的值
+    # 否则使用mode预设的值
+    if not hasattr(args, 'enable_evaluation') or not args.enable_evaluation:
+        args.enable_evaluation = mode_config['enable_evaluation']
+    if not hasattr(args, 'enable_deep_analysis') or not args.enable_deep_analysis:
+        args.enable_deep_analysis = mode_config['enable_deep_analysis']
+    if not hasattr(args, 'enable_similarity') or not args.enable_similarity:
+        args.enable_similarity = mode_config['enable_similarity']
+
+    # 输出运行模式信息
+    logger.info(f"🚀 运行模式: {args.mode}")
+    logger.info(f"  - 结果评估 (Evaluation): {'启用' if args.enable_evaluation else '禁用'}")
+    logger.info(f"  - 深度解构 (Deep Analysis): {'启用' if args.enable_deep_analysis else '禁用'}")
+    logger.info(f"  - 相似度分析 (Similarity): {'启用' if args.enable_similarity else '禁用'}")
+
     # 创建系统实例
     system = EnhancedSearchV2(
         how_json_path=args.how_json,
@@ -1259,22 +1328,22 @@ def main():
         search_max_workers=args.search_workers,
         max_searches_per_feature=args.max_searches_per_feature,
         max_searches_per_base_word=args.max_searches_per_base_word,
-        enable_evaluation=args.enable_stage5,
-        evaluation_max_workers=args.stage5_max_workers,
-        evaluation_max_notes_per_query=args.stage5_max_notes,
-        enable_deep_analysis=args.enable_stage6,
-        deep_analysis_only=args.stage6_only,
-        deep_analysis_max_workers=args.stage6_max_workers,
-        deep_analysis_max_notes=args.stage6_max_notes,
-        deep_analysis_skip_count=args.stage6_skip,
-        deep_analysis_sort_by=args.stage6_sort_by,
-        deep_analysis_api_url=args.stage6_api_url,
-        deep_analysis_min_score=args.stage6_min_score,
-        enable_similarity_analysis=args.enable_stage8,
-        similarity_weight_embedding=args.stage8_weight_embedding,
-        similarity_weight_semantic=args.stage8_weight_semantic,
-        similarity_max_workers=args.stage8_max_workers,
-        similarity_min_similarity=args.stage8_min_similarity
+        enable_evaluation=args.enable_evaluation,
+        evaluation_max_workers=args.evaluation_max_workers,
+        evaluation_max_notes_per_query=args.evaluation_max_notes,
+        enable_deep_analysis=args.enable_deep_analysis,
+        deep_analysis_only=args.deep_analysis_only,
+        deep_analysis_max_workers=args.deep_analysis_max_workers,
+        deep_analysis_max_notes=args.deep_analysis_max_notes,
+        deep_analysis_skip_count=args.deep_analysis_skip,
+        deep_analysis_sort_by=args.deep_analysis_sort_by,
+        deep_analysis_api_url=args.deep_analysis_api_url,
+        deep_analysis_min_score=args.deep_analysis_min_score,
+        enable_similarity=args.enable_similarity,
+        similarity_weight_embedding=args.similarity_weight_embedding,
+        similarity_weight_semantic=args.similarity_weight_semantic,
+        similarity_max_workers=args.similarity_max_workers,
+        similarity_min_similarity=args.similarity_min_threshold
     )
 
     # 执行完整流程