jarvis-ai-assistant 0.3.23__py3-none-any.whl → 0.3.25__py3-none-any.whl

jarvis/jarvis_platform/yuanbao.py

@@ -134,10 +134,11 @@ class YuanbaoPlatform(BasePlatform):
 
         for file_path in file_list:
             file_name = os.path.basename(file_path)
-            PrettyOutput.print(f"上传文件 {file_name}", OutputType.INFO)
+            log_lines: list[str] = []
+            log_lines.append(f"上传文件 {file_name}")
             try:
                 # 1. Prepare the file information
-                PrettyOutput.print(f"准备文件信息: {file_name}", OutputType.INFO)
+                log_lines.append(f"准备文件信息: {file_name}")
                 file_size = os.path.getsize(file_path)
                 file_extension = os.path.splitext(file_path)[1].lower().lstrip(".")
 
@@ -192,23 +193,23 @@ class YuanbaoPlatform(BasePlatform):
                     file_type = "code"
 
                 # 2. Generate upload information
-                PrettyOutput.print(f"获取上传信息: {file_name}", OutputType.INFO)
+                log_lines.append(f"获取上传信息: {file_name}")
                 upload_info = self._generate_upload_info(file_name)
                 if not upload_info:
-                    PrettyOutput.print(
-                        f"无法获取文件 {file_name} 的上传信息", OutputType.ERROR
-                    )
+                    log_lines.append(f"无法获取文件 {file_name} 的上传信息")
+                    PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                     return False
 
                 # 3. Upload the file to COS
-                PrettyOutput.print(f"上传文件到云存储: {file_name}", OutputType.INFO)
+                log_lines.append(f"上传文件到云存储: {file_name}")
                 upload_success = self._upload_file_to_cos(file_path, upload_info)
                 if not upload_success:
-                    PrettyOutput.print(f"上传文件 {file_name} 失败", OutputType.ERROR)
+                    log_lines.append(f"上传文件 {file_name} 失败")
+                    PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                     return False
 
                 # 4. Create file metadata for chat
-                PrettyOutput.print(f"生成文件元数据: {file_name}", OutputType.INFO)
+                log_lines.append(f"生成文件元数据: {file_name}")
                 file_metadata = {
                     "type": file_type,
                     "docType": file_extension if file_extension else file_type,
@@ -226,19 +227,16 @@ class YuanbaoPlatform(BasePlatform):
                             file_metadata["width"] = img.width
                             file_metadata["height"] = img.height
                     except Exception as e:
-                        PrettyOutput.print(
-                            f"无法获取图片 {file_name} 的尺寸: {str(e)}",
-                            OutputType.WARNING,
-                        )
+                        log_lines.append(f"无法获取图片 {file_name} 的尺寸: {str(e)}")
 
                 uploaded_files.append(file_metadata)
-                PrettyOutput.print(f"文件 {file_name} 上传成功", OutputType.SUCCESS)
+                log_lines.append(f"文件 {file_name} 上传成功")
+                PrettyOutput.print("\n".join(log_lines), OutputType.INFO)
                 time.sleep(3)  # 上传成功后等待3秒
 
             except Exception as e:
-                PrettyOutput.print(
-                    f"上传文件 {file_path} 时出错: {str(e)}", OutputType.ERROR
-                )
+                log_lines.append(f"上传文件 {file_path} 时出错: {str(e)}")
+                PrettyOutput.print("\n".join(log_lines), OutputType.ERROR)
                 return False
 
         self.multimedia = uploaded_files

jarvis/jarvis_platform_manager/main.py

@@ -11,8 +11,6 @@ import typer
 from jarvis.jarvis_utils.config import (
     get_normal_platform_name,
     get_normal_model_name,
-    get_thinking_platform_name,
-    get_thinking_model_name,
 )
 
 from jarvis.jarvis_platform.registry import PlatformRegistry
@@ -66,7 +64,7 @@ def list_platforms(
 
 
 def chat_with_model(
-    platform_name: str, model_name: str, system_prompt: str, llm_type: str = "normal"
+    platform_name: str, model_name: str, system_prompt: str
 ) -> None:
     """与指定平台和模型进行对话。
 
@@ -74,7 +72,7 @@ def chat_with_model(
         platform_name: 平台名称
         model_name: 模型名称
         system_prompt: 系统提示语
-        llm_type: LLM类型，可选值：'normal'(普通)或 'thinking'(思考模式)
+
     """
     registry = PlatformRegistry.get_global_platform_registry()
     conversation_history: List[Dict[str, str]] = []  # 存储对话记录
@@ -360,32 +358,19 @@ def chat_command(
         None, "--platform", "-p", help="指定要使用的平台"
     ),
     model: Optional[str] = typer.Option(None, "--model", "-m", help="指定要使用的模型"),
-    llm_type: str = typer.Option(
-        "normal",
-        "-t",
-        "--llm-type",
-        help="使用的LLM类型，可选值：'normal'（普通）或 'thinking'（思考模式）",
-    ),
+
     llm_group: Optional[str] = typer.Option(
         None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
     ),
 ) -> None:
     """与指定平台和模型聊天。"""
     # 如果未提供平台或模型参数，则从config获取默认值
-    platform = platform or (
-        get_thinking_platform_name(llm_group)
-        if llm_type == "thinking"
-        else get_normal_platform_name(llm_group)
-    )
-    model = model or (
-        get_thinking_model_name(llm_group)
-        if llm_type == "thinking"
-        else get_normal_model_name(llm_group)
-    )
+    platform = platform or get_normal_platform_name(llm_group)
+    model = model or get_normal_model_name(llm_group)
 
     if not validate_platform_model(platform, model):
         return
-    chat_with_model(platform, model, "", llm_type)
+    chat_with_model(platform, model, "")
 
 
 @app.command("service")
@@ -444,12 +429,7 @@ def role_command(
     model: Optional[str] = typer.Option(
         None, "--model", "-m", help="指定要使用的模型，覆盖角色配置"
     ),
-    llm_type: Optional[str] = typer.Option(
-        None,
-        "-t",
-        "--llm-type",
-        help="使用的LLM类型，可选值：'normal'（普通）或 'thinking'（思考模式），覆盖角色配置",
-    ),
+
     llm_group: Optional[str] = typer.Option(
         None, "-g", "--llm-group", help="使用的模型组，覆盖配置文件中的设置"
     ),
@@ -483,54 +463,37 @@ def role_command(
         PrettyOutput.print("无效的选择", OutputType.ERROR)
         return
 
-    # 获取llm_type，优先使用命令行参数，否则使用角色配置，默认为normal
-    role_llm_type = llm_type or selected_role.get("llm_type", "normal")
+
 
     # 初始化平台和模型
     # 如果提供了platform或model参数，优先使用命令行参数
-    # 否则，如果提供了llm_group，根据llm_type从配置中获取
+    # 否则，如果提供了 llm_group，则从配置中获取
     # 最后才使用角色配置中的platform和model
     if platform:
         platform_name = platform
     elif llm_group:
-        platform_name = (
-            get_thinking_platform_name(llm_group)
-            if role_llm_type == "thinking"
-            else get_normal_platform_name(llm_group)
-        )
+        platform_name = get_normal_platform_name(llm_group)
     else:
         platform_name = selected_role.get("platform")
         if not platform_name:
             # 如果角色配置中没有platform，使用默认配置
-            platform_name = (
-                get_thinking_platform_name()
-                if role_llm_type == "thinking"
-                else get_normal_platform_name()
-            )
+            platform_name = get_normal_platform_name()
 
     if model:
         model_name = model
     elif llm_group:
-        model_name = (
-            get_thinking_model_name(llm_group)
-            if role_llm_type == "thinking"
-            else get_normal_model_name(llm_group)
-        )
+        model_name = get_normal_model_name(llm_group)
     else:
         model_name = selected_role.get("model")
         if not model_name:
             # 如果角色配置中没有model，使用默认配置
-            model_name = (
-                get_thinking_model_name()
-                if role_llm_type == "thinking"
-                else get_normal_model_name()
-            )
+            model_name = get_normal_model_name()
 
     system_prompt = selected_role.get("system_prompt", "")
 
     # 开始对话
     PrettyOutput.print(f"已选择角色: {selected_role['name']}", OutputType.SUCCESS)
-    chat_with_model(platform_name, model_name, system_prompt, role_llm_type)
+    chat_with_model(platform_name, model_name, system_prompt)
 
 
 def main() -> None:

jarvis/jarvis_rag/cli.py

@@ -240,6 +240,7 @@ def add_documents(
 
         sorted_files = sorted(list(files_to_process))
         total_files = len(sorted_files)
+        loaded_msgs: List[str] = []
 
         for i, file_path in enumerate(sorted_files):
             try:
@@ -249,14 +250,15 @@ def add_documents(
                     loader = TextLoader(str(file_path), encoding="utf-8")
 
                 docs_batch.extend(loader.load())
-                PrettyOutput.print(
-                    f"已加载: {file_path} (文件 {i + 1}/{total_files})", OutputType.INFO
-                )
+                loaded_msgs.append(f"已加载: {file_path} (文件 {i + 1}/{total_files})")
             except Exception as e:
                 PrettyOutput.print(f"加载失败 {file_path}: {e}", OutputType.WARNING)
 
             # 当批处理已满或是最后一个文件时处理批处理
             if docs_batch and (len(docs_batch) >= batch_size or (i + 1) == total_files):
+                if loaded_msgs:
+                    PrettyOutput.print("\n".join(loaded_msgs), OutputType.INFO)
+                    loaded_msgs = []
                 PrettyOutput.print(
                     f"正在处理批次，包含 {len(docs_batch)} 个文档...", OutputType.INFO
                 )
@@ -267,6 +269,10 @@ def add_documents(
                 )
                 docs_batch = []  # 清空批处理
 
+        # 最后统一打印可能残留的“已加载”信息
+        if loaded_msgs:
+            PrettyOutput.print("\n".join(loaded_msgs), OutputType.INFO)
+            loaded_msgs = []
         if total_docs_added == 0:
             PrettyOutput.print("未能成功加载任何文档。", OutputType.ERROR)
             raise typer.Exit(code=1)
@@ -321,12 +327,11 @@ def list_documents(
             )
             return
 
-        PrettyOutput.print(
-            f"知识库 '{collection_name}' 中共有 {len(sources)} 个独立文档:",
-            OutputType.INFO,
-        )
+        # 避免在循环中逐条打印，先拼接后统一打印
+        lines = [f"知识库 '{collection_name}' 中共有 {len(sources)} 个独立文档:"]
         for i, source in enumerate(sorted(list(sources)), 1):
-            PrettyOutput.print(f"  {i}. {source}", OutputType.INFO)
+            lines.append(f"  {i}. {source}")
+        PrettyOutput.print("\n".join(lines), OutputType.INFO)
 
     except Exception as e:
         PrettyOutput.print(f"发生错误: {e}", OutputType.ERROR)
@@ -352,6 +357,12 @@ def retrieve(
         None, "--db-path", help="向量数据库的路径。覆盖全局配置。"
     ),
     n_results: int = typer.Option(5, "--top-n", help="要检索的文档数量。"),
+    rewrite: bool = typer.Option(
+        True,
+        "--rewrite/--no-rewrite",
+        help="是否对查询进行LLM重写以提升召回，默认开启。",
+        show_default=True,
+    ),
 ):
     """仅从RAG知识库检索文档并打印结果。"""
     try:
@@ -366,6 +377,7 @@ def retrieve(
             collection_name=collection_name,
             use_bm25=use_bm25,
             use_rerank=use_rerank,
+            use_query_rewrite=rewrite,
         )
 
         PrettyOutput.print(f"正在为问题检索文档: '{question}'", OutputType.INFO)
@@ -450,11 +462,7 @@ def query(
         PrettyOutput.print(f"正在查询: '{question}'", OutputType.INFO)
         answer = pipeline.query(question)
 
-        PrettyOutput.print("答案:", OutputType.INFO)
-        # 我们仍然可以使用 rich.markdown.Markdown，因为 PrettyOutput 底层使用了 rich
-        from jarvis.jarvis_utils.globals import console
-
-        console.print(Markdown(answer))
+        PrettyOutput.print(answer, OutputType.SUCCESS)
 
     except Exception as e:
         PrettyOutput.print(f"发生错误: {e}", OutputType.ERROR)

jarvis/jarvis_rag/embedding_manager.py

@@ -1,6 +1,9 @@
 import torch
+import os
 from typing import List, cast
 from langchain_huggingface import HuggingFaceEmbeddings
+from huggingface_hub import snapshot_download
+
 
 from .cache import EmbeddingCache
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
@@ -38,12 +41,141 @@ class EmbeddingManager:
         encode_kwargs = {"normalize_embeddings": True}
 
         try:
-            return HuggingFaceEmbeddings(
-                model_name=self.model_name,
-                model_kwargs=model_kwargs,
-                encode_kwargs=encode_kwargs,
-                show_progress=True,
-            )
+            # First try to load model from local cache without any network access
+            try:
+                from sentence_transformers import SentenceTransformer
+                local_dir = None
+                # Prefer explicit local dir via env or direct path
+
+                if os.path.isdir(self.model_name):
+                    return HuggingFaceEmbeddings(
+                        model_name=self.model_name,
+                        model_kwargs=model_kwargs,
+                        encode_kwargs=encode_kwargs,
+                        show_progress=False,
+                    )
+
+                # Try common local cache directories for sentence-transformers and HF hub
+                try:
+                    home = os.path.expanduser("~")
+                    st_home = os.path.join(home, ".cache", "sentence_transformers")
+                    torch_st_home = os.path.join(home, ".cache", "torch", "sentence_transformers")
+                    # Build common name variants found in local caches
+                    org, name = (
+                        self.model_name.split("/", 1)
+                        if "/" in self.model_name
+                        else ("", self.model_name)
+                    )
+                    san1 = self.model_name.replace("/", "_")
+                    san2 = self.model_name.replace("/", "__")
+                    san3 = self.model_name.replace("/", "--")
+                    # include plain 'name' for caches that drop org prefix
+                    name_variants = list(dict.fromkeys([self.model_name, san1, san2, san3, name]))
+                    candidates = []
+                    for base in [st_home, torch_st_home]:
+                        for nv in name_variants:
+                            p = os.path.join(base, nv)
+                            if os.path.isdir(p):
+                                candidates.append(p)
+                        # Fuzzy scan cache directory for entries that include variants
+                        try:
+                            for entry in os.listdir(base):
+                                ep = os.path.join(base, entry)
+                                if not os.path.isdir(ep):
+                                    continue
+                                if (
+                                    (org and entry.startswith(f"{org}__") and name in entry)
+                                    or (san1 in entry)
+                                    or (name in entry)
+                                ):
+                                    candidates.append(ep)
+                        except Exception:
+                            pass
+
+                    # Hugging Face Hub cache snapshots
+                    hf_cache = os.path.join(home, ".cache", "huggingface", "hub")
+                    if "/" in self.model_name:
+                        org, name = self.model_name.split("/", 1)
+                        models_dir = os.path.join(hf_cache, f"models--{org}--{name}", "snapshots")
+                        if os.path.isdir(models_dir):
+                            try:
+                                snaps = sorted(
+                                    [os.path.join(models_dir, d) for d in os.listdir(models_dir)],
+                                    key=lambda p: os.path.getmtime(p),
+                                    reverse=True,
+                                )
+                            except Exception:
+                                snaps = [os.path.join(models_dir, d) for d in os.listdir(models_dir)]
+                            for sp in snaps:
+                                if os.path.isdir(sp):
+                                    candidates.append(sp)
+                                    break
+
+                    for cand in candidates:
+                        try:
+                            return HuggingFaceEmbeddings(
+                                model_name=cand,
+                                model_kwargs=model_kwargs,
+                                encode_kwargs=encode_kwargs,
+                                show_progress=False,
+                            )
+                        except Exception:
+                            continue
+                except Exception:
+                    pass
+
+                try:
+                    # Try resolve local cached directory; do not hit network
+                    local_dir = snapshot_download(repo_id=self.model_name, local_files_only=True)
+                except Exception:
+                    local_dir = None
+
+                if local_dir:
+                    return HuggingFaceEmbeddings(
+                        model_name=local_dir,
+                        model_kwargs=model_kwargs,
+                        encode_kwargs=encode_kwargs,
+                        show_progress=False,
+                    )
+
+
+
+                # Fall back to remote download if local cache not found and not offline
+                return HuggingFaceEmbeddings(
+                    model_name=self.model_name,
+                    model_kwargs=model_kwargs,
+                    encode_kwargs=encode_kwargs,
+                    show_progress=True,
+                )
+            except Exception as _e:
+                # 如果已检测到本地候选路径（直接目录 / 本地缓存快照），则视为本地加载失败，
+                # 为避免在用户期望“本地优先不联网”的情况下触发联网，直接抛错并给出修复建议。
+                had_local_candidate = False
+                try:
+                    had_local_candidate = (
+                        os.path.isdir(self.model_name)
+                        # 如果上面 snapshot_download 命中了本地缓存，会将 local_dir 设为非 None
+                        or (locals().get("local_dir") is not None)
+                    )
+                except Exception:
+                    pass
+
+                if had_local_candidate:
+                    PrettyOutput.print(
+                        "检测到本地模型路径但加载失败。为避免触发网络访问，已中止远程回退。\n"
+                        "请确认本地目录包含完整的 Transformers/Tokenizer 文件（如 config.json、model.safetensors、tokenizer.json/merges.txt 等），\n"
+                        "或在配置中将 embedding_model 设置为该本地目录，或将模型放置到默认的 Hugging Face 缓存目录（例如 ~/.cache/huggingface/hub）。",
+                        OutputType.ERROR,
+                    )
+                    raise
+
+                # 未发现任何本地候选，则保持原有行为：回退至远程下载
+                return HuggingFaceEmbeddings(
+                    model_name=self.model_name,
+                    model_kwargs=model_kwargs,
+                    encode_kwargs=encode_kwargs,
+                    show_progress=True,
+                )
         except Exception as e:
             PrettyOutput.print(
                 f"加载嵌入模型 '{self.model_name}' 时出错: {e}", OutputType.ERROR

jarvis/jarvis_rag/llm_interface.py

@@ -47,13 +47,11 @@ class ToolAgent_LLM(LLMInterface):
         # 为代理提供一个通用的系统提示
         self.system_prompt = "You are a helpful assistant. Please answer the user's question based on the provided context. You can use tools to find more information if needed."
         self.summary_prompt = """
-<report>
 请为本次问答任务生成一个总结报告，包含以下内容：
 
 1. **原始问题**: 重述用户最开始提出的问题。
 2. **关键信息来源**: 总结你是基于哪些关键信息或文件得出的结论。
 3. **最终答案**: 给出最终的、精炼的回答。
-</report>
 """
 
     def generate(self, prompt: str, **kwargs) -> str:

jarvis/jarvis_rag/rag_pipeline.py

@@ -34,6 +34,7 @@ class JarvisRAGPipeline:
         collection_name: str = "jarvis_rag_collection",
         use_bm25: bool = True,
         use_rerank: bool = True,
+        use_query_rewrite: bool = True,
     ):
         """
         初始化RAG管道。
@@ -69,6 +70,8 @@ class JarvisRAGPipeline:
         self.collection_name = collection_name
         self.use_bm25 = use_bm25
         self.use_rerank = use_rerank
+        # 查询重写开关（默认开启，可由CLI控制）
+        self.use_query_rewrite = use_query_rewrite
 
         # 延迟加载的组件
         self._embedding_manager: Optional[EmbeddingManager] = None
@@ -161,14 +164,15 @@ class JarvisRAGPipeline:
             if not changed and not deleted:
                 return
             # 打印摘要
-            PrettyOutput.print(
-                f"检测到索引可能不一致：变更 {len(changed)} 个，删除 {len(deleted)} 个。",
-                OutputType.WARNING,
-            )
-            for p in changed[:3] if changed else []:
-                PrettyOutput.print(f"  变更: {p}", OutputType.WARNING)
-            for p in deleted[:3] if deleted else []:
-                PrettyOutput.print(f"  删除: {p}", OutputType.WARNING)
+            # 先拼接列表信息再统一打印，避免循环中逐条打印
+            lines = [
+                f"检测到索引可能不一致：变更 {len(changed)} 个，删除 {len(deleted)} 个。"
+            ]
+            if changed:
+                lines.extend([f"  变更: {p}" for p in changed[:3]])
+            if deleted:
+                lines.extend([f"  删除: {p}" for p in deleted[:3]])
+            PrettyOutput.print("\n".join(lines), OutputType.WARNING)
             # 询问用户
             if get_yes_no(
                 "检测到索引变更，是否现在更新索引后再开始检索？", default=True
@@ -228,13 +232,23 @@ class JarvisRAGPipeline:
         """
         # 0. 检测索引变更并可选更新（在重写query之前）
         self._pre_search_update_index_if_needed()
-        # 1. 将原始查询重写为多个查询
-        rewritten_queries = self._get_query_rewriter().rewrite(query_text)
+        # 1. 将原始查询重写为多个查询（可配置）
+        if self.use_query_rewrite:
+            rewritten_queries = self._get_query_rewriter().rewrite(query_text)
+        else:
+            PrettyOutput.print(
+                "已关闭查询重写，将直接使用原始查询进行检索。",
+                OutputType.INFO,
+            )
+            rewritten_queries = [query_text]
 
         # 2. 为每个重写的查询检索初始候选文档
+        PrettyOutput.print(
+            "将为以下查询变体进行混合检索:\n" + "\n".join([f"  - {q}" for q in rewritten_queries]),
+            OutputType.INFO,
+        )
         all_candidate_docs = []
         for q in rewritten_queries:
-            PrettyOutput.print(f"正在为查询变体 '{q}' 进行混合检索...", OutputType.INFO)
             candidates = self._get_retriever().retrieve(
                 q, n_results=n_results * 2, use_bm25=self.use_bm25
             )
@@ -273,9 +287,9 @@ class JarvisRAGPipeline:
             )
         )
         if sources:
-            PrettyOutput.print("根据以下文档回答:", OutputType.INFO)
-            for source in sources:
-                PrettyOutput.print(f"  - {source}", OutputType.INFO)
+            # 合并来源列表后一次性打印，避免多次加框
+            lines = ["根据以下文档回答:"] + [f"  - {source}" for source in sources]
+            PrettyOutput.print("\n".join(lines), OutputType.INFO)
 
         # 4. 创建最终提示并生成答案
         # 我们使用原始的query_text作为给LLM的最终提示
@@ -299,13 +313,23 @@ class JarvisRAGPipeline:
         """
         # 0. 检测索引变更并可选更新（在重写query之前）
         self._pre_search_update_index_if_needed()
-        # 1. 重写查询
-        rewritten_queries = self._get_query_rewriter().rewrite(query_text)
+        # 1. 重写查询（可配置）
+        if self.use_query_rewrite:
+            rewritten_queries = self._get_query_rewriter().rewrite(query_text)
+        else:
+            PrettyOutput.print(
+                "已关闭查询重写，将直接使用原始查询进行检索。",
+                OutputType.INFO,
+            )
+            rewritten_queries = [query_text]
 
         # 2. 检索候选文档
+        PrettyOutput.print(
+            "将为以下查询变体进行混合检索:\n" + "\n".join([f"  - {q}" for q in rewritten_queries]),
+            OutputType.INFO,
+        )
         all_candidate_docs = []
         for q in rewritten_queries:
-            PrettyOutput.print(f"正在为查询变体 '{q}' 进行混合检索...", OutputType.INFO)
             candidates = self._get_retriever().retrieve(
                 q, n_results=n_results * 2, use_bm25=self.use_bm25
             )

jarvis/jarvis_rag/reranker.py

@@ -1,9 +1,11 @@
 from typing import List
+import os
 
 from langchain.docstore.document import Document
 from sentence_transformers.cross_encoder import (  # type: ignore
     CrossEncoder,
 )
+from huggingface_hub import snapshot_download
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
@@ -21,8 +23,28 @@ class Reranker:
             model_name (str): 要使用的Cross-Encoder模型的名称。
         """
         PrettyOutput.print(f"正在初始化重排模型: {model_name}...", OutputType.INFO)
-        self.model = CrossEncoder(model_name)
-        PrettyOutput.print("重排模型初始化成功。", OutputType.SUCCESS)
+        try:
+            local_dir = None
+
+            if os.path.isdir(model_name):
+                self.model = CrossEncoder(model_name)
+                PrettyOutput.print("重排模型初始化成功。", OutputType.SUCCESS)
+                return
+            try:
+                # Prefer local cache; avoid any network access
+                local_dir = snapshot_download(repo_id=model_name, local_files_only=True)
+            except Exception:
+                local_dir = None
+
+            if local_dir:
+                self.model = CrossEncoder(local_dir)
+            else:
+                self.model = CrossEncoder(model_name)
+
+            PrettyOutput.print("重排模型初始化成功。", OutputType.SUCCESS)
+        except Exception as e:
+            PrettyOutput.print(f"初始化重排模型失败: {e}", OutputType.ERROR)
+            raise
 
     def rerank(
         self, query: str, documents: List[Document], top_n: int = 5