jarvis-ai-assistant 0.1.220__py3-none-any.whl → 0.1.222__py3-none-any.whl

jarvis/jarvis_rag/query_rewriter.py

@@ -4,22 +4,21 @@ from .llm_interface import LLMInterface
 
 class QueryRewriter:
     """
-    Uses an LLM to rewrite a user's query into multiple, diverse search
-    queries to enhance retrieval recall.
+    使用LLM将用户的查询重写为多个不同的搜索查询，以提高检索召回率。
     """
 
     def __init__(self, llm: LLMInterface):
         """
-        Initializes the QueryRewriter.
+        初始化QueryRewriter。
 
-        Args:
-            llm: An instance of a class implementing LLMInterface.
+        参数:
+            llm: 实现LLMInterface接口的类的实例。
         """
         self.llm = llm
         self.rewrite_prompt_template = self._create_prompt_template()
 
     def _create_prompt_template(self) -> str:
-        """Creates the prompt template for the multi-query rewriting task."""
+        """为多查询重写任务创建提示模板。"""
         return """
 你是一个精通检索的AI助手。你的任务是将以下这个单一的用户问题，从不同角度改写成 3 个不同的、但语义上相关的搜索查询。这有助于在知识库中进行更全面的搜索。
 
@@ -39,13 +38,13 @@ class QueryRewriter:
 
     def rewrite(self, query: str) -> List[str]:
         """
-        Rewrites the user query into multiple queries using the LLM.
+        使用LLM将用户查询重写为多个查询。
 
-        Args:
-            query: The original user query.
+        参数:
+            query: 原始用户查询。
 
-        Returns:
-            A list of rewritten, search-optimized queries.
+        返回:
+            一个经过重写、搜索优化的查询列表。
         """
         prompt = self.rewrite_prompt_template.format(query=query)
         print(f"✍️  正在将原始查询重写为多个搜索查询...")
@@ -55,7 +54,7 @@ class QueryRewriter:
             line.strip() for line in response_text.strip().split("\n") if line.strip()
         ]
 
-        # Also include the original query for robustness
+        # 同时包含原始查询以保证鲁棒性
         if query not in rewritten_queries:
             rewritten_queries.insert(0, query)
 

jarvis/jarvis_rag/rag_pipeline.py

@@ -1,5 +1,5 @@
 import os
-from typing import List, Literal, Optional, cast
+from typing import List, Optional
 
 from langchain.docstore.document import Document
 
@@ -9,57 +9,55 @@ from .query_rewriter import QueryRewriter
 from .reranker import Reranker
 from .retriever import ChromaRetriever
 from jarvis.jarvis_utils.config import (
-    get_rag_embedding_mode,
+    get_rag_embedding_model,
+    get_rag_rerank_model,
     get_rag_vector_db_path,
     get_rag_embedding_cache_path,
-    get_rag_embedding_models,
 )
 
 
 class JarvisRAGPipeline:
     """
-    The main orchestrator for the RAG pipeline.
+    RAG管道的主要协调器。
 
-    This class integrates the embedding manager, retriever, and LLM to provide
-    a complete pipeline for adding documents and querying them.
+    该类集成了嵌入管理器、检索器和LLM，为添加文档和查询
+    提供了一个完整的管道。
     """
 
     def __init__(
         self,
         llm: Optional[LLMInterface] = None,
-        embedding_mode: Optional[Literal["performance", "accuracy"]] = None,
+        embedding_model: Optional[str] = None,
         db_path: Optional[str] = None,
         collection_name: str = "jarvis_rag_collection",
     ):
         """
-        Initializes the RAG pipeline.
-
-        Args:
-            llm: An instance of a class implementing LLMInterface.
-                 If None, defaults to the ToolAgent_LLM.
-            embedding_mode: The mode for the local embedding model. If None, uses config value.
-            db_path: Path to the persistent vector database. If None, uses config value.
-            collection_name: Name of the collection in the vector database.
+        初始化RAG管道。
+
+        参数:
+            llm: 实现LLMInterface接口的类的实例。
+                 如果为None，则默认为ToolAgent_LLM。
+            embedding_model: 嵌入模型的名称。如果为None，则使用配置值。
+            db_path: 持久化向量数据库的路径。如果为None，则使用配置值。
+            collection_name: 向量数据库中集合的名称。
         """
-        # Determine the embedding model to isolate data paths
-        _embedding_mode = embedding_mode or get_rag_embedding_mode()
-        embedding_models = get_rag_embedding_models()
-        model_name = embedding_models[_embedding_mode]["model_name"]
+        # 确定嵌入模型以隔离数据路径
+        model_name = embedding_model or get_rag_embedding_model()
         sanitized_model_name = model_name.replace("/", "_").replace("\\", "_")
 
-        # If a specific db_path is given, use it. Otherwise, create a model-specific path.
+        # 如果给定了特定的db_path，则使用它。否则，创建一个特定于模型的路径。
         _final_db_path = (
             str(db_path)
             if db_path
             else os.path.join(get_rag_vector_db_path(), sanitized_model_name)
         )
-        # Always create a model-specific cache path.
+        # 始终创建一个特定于模型的缓存路径。
         _final_cache_path = os.path.join(
             get_rag_embedding_cache_path(), sanitized_model_name
         )
 
         self.embedding_manager = EmbeddingManager(
-            mode=cast(Literal["performance", "accuracy"], _embedding_mode),
+            model_name=model_name,
             cache_dir=_final_cache_path,
         )
         self.retriever = ChromaRetriever(
@@ -67,27 +65,27 @@ class JarvisRAGPipeline:
             db_path=_final_db_path,
             collection_name=collection_name,
         )
-        # Default to the ToolAgent_LLM unless a specific LLM is provided
+        # 除非提供了特定的LLM，否则默认为ToolAgent_LLM
         self.llm = llm if llm is not None else ToolAgent_LLM()
-        self.reranker = Reranker()
-        # Use a standard LLM for the query rewriting task, not the agent
+        self.reranker = Reranker(model_name=get_rag_rerank_model())
+        # 使用标准LLM执行查询重写任务，而不是代理
         self.query_rewriter = QueryRewriter(JarvisPlatform_LLM())
 
         print("✅ JarvisRAGPipeline 初始化成功。")
 
     def add_documents(self, documents: List[Document]):
         """
-        Adds documents to the vector knowledge base.
+        将文档添加到向量知识库。
 
-        Args:
-            documents: A list of LangChain Document objects to add.
+        参数:
+            documents: 要添加的LangChain文档对象列表。
         """
         self.retriever.add_documents(documents)
 
     def _create_prompt(
         self, query: str, context_docs: List[Document], source_files: List[str]
     ) -> str:
-        """Creates the final prompt for the LLM or Agent."""
+        """为LLM或代理创建最终的提示。"""
         context = "\n\n".join([doc.page_content for doc in context_docs])
         sources_text = "\n".join([f"- {source}" for source in source_files])
 
@@ -114,34 +112,33 @@ class JarvisRAGPipeline:
 
     def query(self, query_text: str, n_results: int = 5) -> str:
         """
-        Performs a query against the knowledge base using a multi-query
-        retrieval and reranking pipeline.
+        使用多查询检索和重排管道对知识库执行查询。
 
-        Args:
-            query_text: The user's original question.
-            n_results: The number of final relevant chunks to retrieve.
+        参数:
+            query_text: 用户的原始问题。
+            n_results: 要检索的最终相关块的数量。
 
-        Returns:
-            The answer generated by the LLM.
+        返回:
+            由LLM生成的答案。
         """
-        # 1. Rewrite the original query into multiple queries
+        # 1. 将原始查询重写为多个查询
         rewritten_queries = self.query_rewriter.rewrite(query_text)
 
-        # 2. Retrieve initial candidates for each rewritten query
+        # 2. 为每个重写的查询检索初始候选文档
         all_candidate_docs = []
         for q in rewritten_queries:
             print(f"🔍 正在为查询变体 '{q}' 进行混合检索...")
             candidates = self.retriever.retrieve(q, n_results=n_results * 2)
             all_candidate_docs.extend(candidates)
 
-        # De-duplicate the candidate documents
+        # 对候选文档进行去重
         unique_docs_dict = {doc.page_content: doc for doc in all_candidate_docs}
         unique_candidate_docs = list(unique_docs_dict.values())
 
         if not unique_candidate_docs:
             return "我在提供的文档中找不到任何相关信息来回答您的问题。"
 
-        # 3. Rerank the unified candidate pool against the *original* query
+        # 3. 根据*原始*查询对统一的候选池进行重排
         print(
             f"🔍 正在对 {len(unique_candidate_docs)} 个候选文档进行重排（基于原始问题）..."
         )
@@ -152,7 +149,7 @@ class JarvisRAGPipeline:
         if not retrieved_docs:
             return "我在提供的文档中找不到任何相关信息来回答您的问题。"
 
-        # Print the sources of the final retrieved documents
+        # 打印最终检索到的文档的来源
         sources = sorted(
             list(
                 {
@@ -167,8 +164,8 @@ class JarvisRAGPipeline:
             for source in sources:
                 print(f"  - {source}")
 
-        # 4. Create the final prompt and generate the answer
-        # We use the original query_text for the final prompt to the LLM
+        # 4. 创建最终提示并生成答案
+        # 我们使用原始的query_text作为给LLM的最终提示
         prompt = self._create_prompt(query_text, retrieved_docs, sources)
 
         print("🤖 正在从LLM生成答案...")

jarvis/jarvis_rag/reranker.py

@@ -8,16 +8,16 @@ from sentence_transformers.cross_encoder import (  # type: ignore
 
 class Reranker:
     """
-    A reranker class that uses a Cross-Encoder model to re-score and sort
-    documents based on their relevance to a given query.
+    一个重排器类，使用Cross-Encoder模型根据文档与给定查询的相关性
+    对文档进行重新评分和排序。
     """
 
-    def __init__(self, model_name: str = "BAAI/bge-reranker-base"):
+    def __init__(self, model_name: str):
         """
-        Initializes the Reranker.
+        初始化重排器。
 
-        Args:
-            model_name (str): The name of the Cross-Encoder model to use.
+        参数:
+            model_name (str): 要使用的Cross-Encoder模型的名称。
         """
         print(f"🔍 正在初始化重排模型: {model_name}...")
         self.model = CrossEncoder(model_name)
@@ -27,30 +27,30 @@ class Reranker:
         self, query: str, documents: List[Document], top_n: int = 5
     ) -> List[Document]:
         """
-        Reranks a list of documents based on their relevance to the query.
+        根据文档与查询的相关性对文档列表进行重排。
 
-        Args:
-            query (str): The user's query.
-            documents (List[Document]): The list of documents retrieved from the initial search.
-            top_n (int): The number of top documents to return after reranking.
+        参数:
+            query (str): 用户的查询。
+            documents (List[Document]): 从初始搜索中检索到的文档列表。
+            top_n (int): 重排后要返回的顶部文档数。
 
-        Returns:
-            List[Document]: A sorted list of the most relevant documents.
+        返回:
+            List[Document]: 一个已排序的最相关文档列表。
         """
         if not documents:
             return []
 
-        # Create pairs of [query, document_content] for scoring
+        # 创建 [查询, 文档内容] 对用于评分
         pairs = [[query, doc.page_content] for doc in documents]
 
-        # Get scores from the Cross-Encoder model
+        # 从Cross-Encoder模型获取分数
         scores = self.model.predict(pairs)
 
-        # Combine documents with their scores and sort
+        # 将文档与它们的分数结合并排序
         doc_with_scores = list(zip(documents, scores))
-        doc_with_scores.sort(key=lambda x: x[1], reverse=True)
+        doc_with_scores.sort(key=lambda x: x[1], reverse=True)  # type: ignore
 
-        # Return the top N documents
+        # 返回前N个文档
         reranked_docs = [doc for doc, score in doc_with_scores[:top_n]]
 
         return reranked_docs

jarvis/jarvis_rag/retriever.py

@@ -12,8 +12,8 @@ from .embedding_manager import EmbeddingManager
 
 class ChromaRetriever:
     """
-    A retriever class that combines dense vector search (ChromaDB) and
-    sparse keyword search (BM25) for hybrid retrieval.
+    一个检索器类，它结合了密集向量搜索（ChromaDB）和稀疏关键字搜索（BM25）
+    以实现混合检索。
     """
 
     def __init__(
@@ -23,18 +23,18 @@ class ChromaRetriever:
         collection_name: str = "jarvis_rag_collection",
     ):
         """
-        Initializes the ChromaRetriever.
+        初始化ChromaRetriever。
 
-        Args:
-            embedding_manager: An instance of EmbeddingManager.
-            db_path: The file path for ChromaDB's persistent storage.
-            collection_name: The name of the collection within ChromaDB.
+        参数:
+            embedding_manager: EmbeddingManager的实例。
+            db_path: ChromaDB持久化存储的文件路径。
+            collection_name: ChromaDB中集合的名称。
         """
         self.embedding_manager = embedding_manager
         self.db_path = db_path
         self.collection_name = collection_name
 
-        # Initialize ChromaDB client
+        # 初始化ChromaDB客户端
         self.client = chromadb.PersistentClient(path=self.db_path)
         self.collection = self.client.get_or_create_collection(
             name=self.collection_name
@@ -43,12 +43,12 @@ class ChromaRetriever:
             f"✅ ChromaDB 客户端已在 '{db_path}' 初始化，集合为 '{collection_name}'。"
         )
 
-        # BM25 Index setup
+        # BM25索引设置
         self.bm25_index_path = os.path.join(self.db_path, f"{collection_name}_bm25.pkl")
         self._load_or_initialize_bm25()
 
     def _load_or_initialize_bm25(self):
-        """Loads the BM25 index from disk or initializes a new one."""
+        """从磁盘加载BM25索引或初始化一个新索引。"""
         if os.path.exists(self.bm25_index_path):
             print("🔍 正在加载现有的 BM25 索引...")
             with open(self.bm25_index_path, "rb") as f:
@@ -62,7 +62,7 @@ class ChromaRetriever:
             self.bm25_index = None
 
     def _save_bm25_index(self):
-        """Saves the BM25 index to disk."""
+        """将BM25索引保存到磁盘。"""
         if self.bm25_index:
             print("💾 正在保存 BM25 索引...")
             with open(self.bm25_index_path, "wb") as f:
@@ -73,7 +73,7 @@ class ChromaRetriever:
         self, documents: List[Document], chunk_size=1000, chunk_overlap=100
     ):
         """
-        Splits, embeds, and adds documents to both ChromaDB and the BM25 index.
+        将文档拆分、嵌入，并添加到ChromaDB和BM25索引中。
         """
         text_splitter = RecursiveCharacterTextSplitter(
             chunk_size=chunk_size, chunk_overlap=chunk_overlap
@@ -85,13 +85,13 @@ class ChromaRetriever:
         if not chunks:
             return
 
-        # Extract content, metadata, and generate IDs
+        # 提取内容、元数据并生成ID
         chunk_texts = [chunk.page_content for chunk in chunks]
         metadatas = [chunk.metadata for chunk in chunks]
         start_id = self.collection.count()
         ids = [f"doc_{i}" for i in range(start_id, start_id + len(chunks))]
 
-        # Add to ChromaDB
+        # 添加到ChromaDB
         embeddings = self.embedding_manager.embed_documents(chunk_texts)
         self.collection.add(
             ids=ids,
@@ -101,7 +101,7 @@ class ChromaRetriever:
         )
         print(f"✅ 成功将 {len(chunks)} 个块添加到 ChromaDB 集合中。")
 
-        # Update and save BM25 index
+        # 更新并保存BM25索引
         tokenized_chunks = [doc.split() for doc in chunk_texts]
         self.bm25_corpus.extend(tokenized_chunks)
         self.bm25_index = BM25Okapi(self.bm25_corpus)
@@ -109,30 +109,30 @@ class ChromaRetriever:
 
     def retrieve(self, query: str, n_results: int = 5) -> List[Document]:
         """
-        Performs hybrid retrieval using both vector search and BM25,
-        then fuses the results using Reciprocal Rank Fusion (RRF).
+        使用向量搜索和BM25执行混合检索，然后使用倒数排序融合（RRF）
+        对结果进行融合。
         """
-        # 1. Vector Search (ChromaDB)
+        # 1. 向量搜索 (ChromaDB)
         query_embedding = self.embedding_manager.embed_query(query)
         vector_results = self.collection.query(
             query_embeddings=cast(Any, [query_embedding]),
-            n_results=n_results * 2,  # Retrieve more results for fusion
+            n_results=n_results * 2,  # 检索更多结果用于融合
         )
 
-        # 2. Keyword Search (BM25)
+        # 2. 关键字搜索 (BM25)
         bm25_docs = []
         if self.bm25_index:
             tokenized_query = query.split()
             doc_scores = self.bm25_index.get_scores(tokenized_query)
 
-            # Get all documents from Chroma to match with BM25 scores
+            # 从Chroma获取所有文档以匹配BM25分数
             all_docs_in_collection = self.collection.get()
             all_documents = all_docs_in_collection.get("documents")
             all_metadatas = all_docs_in_collection.get("metadatas")
 
             bm25_results_with_docs = []
             if all_documents and all_metadatas:
-                # Create a mapping from index to document
+                # 创建从索引到文档的映射
                 bm25_results_with_docs = [
                     (
                         all_documents[i],
@@ -143,17 +143,17 @@ class ChromaRetriever:
                     if score > 0
                 ]
 
-            # Sort by score and take top results
+            # 按分数排序并取最高结果
             bm25_results_with_docs.sort(key=lambda x: x[2], reverse=True)
 
             for doc_text, metadata, _ in bm25_results_with_docs[: n_results * 2]:
                 bm25_docs.append(Document(page_content=doc_text, metadata=metadata))
 
-        # 3. Reciprocal Rank Fusion (RRF)
+        # 3. 倒数排序融合 (RRF)
         fused_scores: Dict[str, float] = {}
-        k = 60  # RRF ranking constant
+        k = 60  # RRF排名常数
 
-        # Process vector results
+        # 处理向量结果
         if vector_results and vector_results["ids"] and vector_results["documents"]:
             vec_ids = vector_results["ids"][0]
             vec_texts = vector_results["documents"][0]
@@ -161,7 +161,7 @@ class ChromaRetriever:
             for rank, doc_id in enumerate(vec_ids):
                 fused_scores[doc_id] = fused_scores.get(doc_id, 0) + 1 / (k + rank)
 
-            # Create a map from document text to its ID for BM25 fusion
+            # 为BM25融合创建从文档文本到其ID的映射
             doc_text_to_id = {text: doc_id for text, doc_id in zip(vec_texts, vec_ids)}
 
             for rank, doc in enumerate(bm25_docs):
@@ -171,12 +171,12 @@ class ChromaRetriever:
                         k + rank
                     )
 
-        # Sort fused results
+        # 对融合结果进行排序
         sorted_fused_results = sorted(
             fused_scores.items(), key=lambda x: x[1], reverse=True
         )
 
-        # Get the final documents from ChromaDB based on fused ranking
+        # 根据融合排名从ChromaDB获取最终文档
         final_doc_ids = [item[0] for item in sorted_fused_results[:n_results]]
 
         if not final_doc_ids:

jarvis/jarvis_tools/edit_file.py

@@ -7,15 +7,12 @@
 2. 支持单个文件的编辑操作，包括创建新文件
 3. 实现原子操作：所有修改要么全部成功，要么全部回滚
 4. 严格匹配控制：每个搜索文本必须且只能匹配一次
-5. 支持两种编辑模式：快速编辑(fast_edit)和AI辅助编辑(slow_edit)
 
 核心特性:
 - 支持不存在的文件和空文件处理
 - 自动创建所需目录结构
 - 完善的错误处理和回滚机制
 - 严格的格式保持要求
-- 支持大文件处理(自动上传到模型平台)
-- 提供3次重试机制确保操作可靠性
 """
 from typing import Any, Dict
 
@@ -134,7 +131,6 @@ class FileSearchReplaceTool:
         for file_info in args["files"]:
             file_path = os.path.abspath(file_info["path"])
             changes = file_info["changes"]
-            agent = args.get("agent", None)
 
             # 创建已处理文件变量，用于失败时回滚
             original_content = None
@@ -152,44 +148,23 @@ class FileSearchReplaceTool:
                             content = f.read()
                             original_content = content
 
-                    if file_exists and agent:
-                        files = agent.get_user_data("files")
-                        if not files or file_path not in files:
-                            file_results.append(
-                                {
-                                    "file": file_path,
-                                    "success": False,
-                                    "stdout": "",
-                                    "stderr": f"请先读取文件 {file_path} 的内容后再编辑",
-                                }
-                            )
-                            continue
-
                     print(f"⚙️ 正在处理文件 {file_path}...")
-                    # 首先尝试fast_edit模式
                     success, temp_content = EditFileHandler._fast_edit(
                         file_path, changes
                     )
                     if not success:
-                        # 如果fast_edit失败，尝试slow_edit模式
-                        success, temp_content = EditFileHandler._slow_edit(
-                            file_path, changes, agent
+                        print(f"❌ 文件 {file_path} 处理失败")
+                        file_results.append(
+                            {
+                                "file": file_path,
+                                "success": False,
+                                "stdout": "",
+                                "stderr": temp_content,
+                            }
                         )
-                        if not success:
-                            print(f"❌ 文件 {file_path} 处理失败")
-                            file_results.append(
-                                {
-                                    "file": file_path,
-                                    "success": False,
-                                    "stdout": "",
-                                    "stderr": temp_content,
-                                }
-                            )
-                            continue
-                        else:
-                            print(f"✅ 文件 {file_path} 内容生成完成")
-                    else:
-                        print(f"✅ 文件 {file_path} 内容生成完成")
+                        continue
+
+                    print(f"✅ 文件 {file_path} 内容生成完成")
 
                     # 只有当所有替换操作都成功时，才写回文件
                     if success and (

jarvis/jarvis_utils/config.py

@@ -241,6 +241,16 @@ def is_print_prompt() -> bool:
     return GLOBAL_CONFIG_DATA.get("JARVIS_PRINT_PROMPT", False) == True
 
 
+def is_enable_static_analysis() -> bool:
+    """
+    获取是否启用静态代码分析。
+
+    返回：
+        bool: 如果启用静态代码分析则返回True，默认为True
+    """
+    return GLOBAL_CONFIG_DATA.get("JARVIS_ENABLE_STATIC_ANALYSIS", True) is True
+
+
 def get_mcp_config() -> List[Dict[str, Any]]:
     """
     获取MCP配置列表。
@@ -255,21 +265,6 @@ def get_mcp_config() -> List[Dict[str, Any]]:
 # RAG Framework Configuration
 # ==============================================================================
 
-EMBEDDING_MODELS = {
-    "performance": {
-        "model_name": "BAAI/bge-base-zh-v1.5",
-        "model_kwargs": {"device": "cuda" if torch.cuda.is_available() else "cpu"},
-        "encode_kwargs": {"normalize_embeddings": True},
-        "show_progress": True,
-    },
-    "accuracy": {
-        "model_name": "BAAI/bge-large-zh-v1.5",
-        "model_kwargs": {"device": "cuda" if torch.cuda.is_available() else "cpu"},
-        "encode_kwargs": {"normalize_embeddings": True},
-        "show_progress": True,
-    },
-}
-
 
 def get_rag_config() -> Dict[str, Any]:
     """
@@ -281,24 +276,24 @@ def get_rag_config() -> Dict[str, Any]:
     return GLOBAL_CONFIG_DATA.get("JARVIS_RAG", {})
 
 
-def get_rag_embedding_models() -> Dict[str, Any]:
+def get_rag_embedding_model() -> str:
     """
-    获取RAG嵌入模型的定义。
+    获取RAG嵌入模型的名称。
 
     返回:
-        Dict[str, Any]: 嵌入模型配置字典
+        str: 嵌入模型的名称
     """
-    return EMBEDDING_MODELS
+    return get_rag_config().get("embedding_model", "BAAI/bge-base-zh-v1.5")
 
 
-def get_rag_embedding_mode() -> str:
+def get_rag_rerank_model() -> str:
     """
-    获取RAG嵌入模型的模式。
+    获取RAG rerank模型的名称。
 
     返回:
-        str: 'performance' 或 'accuracy'
+        str: rerank模型的名称
     """
-    return get_rag_config().get("embedding_mode", "performance")
+    return get_rag_config().get("rerank_model", "BAAI/bge-reranker-base")
 
 
 def get_rag_embedding_cache_path() -> str:
@@ -308,7 +303,7 @@ def get_rag_embedding_cache_path() -> str:
     返回:
         str: 缓存路径
     """
-    return get_rag_config().get("embedding_cache_path", ".jarvis/rag/embeddings")
+    return ".jarvis/rag/embeddings"
 
 
 def get_rag_vector_db_path() -> str:
@@ -318,4 +313,4 @@ def get_rag_vector_db_path() -> str:
     返回:
         str: 数据库路径
     """
-    return get_rag_config().get("vector_db_path", ".jarvis/rag/vectordb")
+    return ".jarvis/rag/vectordb"