jarvis-ai-assistant 0.1.100__py3-none-any.whl → 0.1.102__py3-none-any.whl

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.100" 
+__version__ = "0.1.102" 

jarvis/agent.py

@@ -8,7 +8,7 @@ import yaml
 from jarvis.models.registry import PlatformRegistry
 from jarvis.tools import ToolRegistry
 from jarvis.tools.registry import load_tools
-from jarvis.utils import PrettyOutput, OutputType, get_single_line_input, load_methodology, add_agent, delete_current_agent, get_max_context_length, get_multiline_input, load_embedding_model, init_env
+from jarvis.utils import PrettyOutput, OutputType, get_single_line_input, load_methodology, add_agent, delete_current_agent, get_max_context_length, get_multiline_input, init_env
 import os
 
 class Agent:
@@ -35,29 +35,9 @@ class Agent:
         self.conversation_length = 0  # Use length counter instead
         self.system_prompt = system_prompt
         # Load configuration from environment variables
-        self.embedding_dimension = 1536  # Default for many embedding models
+        
         self.max_context_length = get_max_context_length()
         
-        # Initialize embedding model
-        try:
-            self.embedding_model = load_embedding_model()
-            
-            # Warm up model and get correct dimension
-            test_text = "This is a test text to ensure the model is fully loaded."
-            test_embedding = self.embedding_model.encode(
-                test_text, 
-                convert_to_tensor=True,
-                normalize_embeddings=True
-            )
-            self.embedding_dimension = len(test_embedding)
-            PrettyOutput.print("Successfully loaded embedding model", OutputType.SUCCESS)
-            
-            # Initialize HNSW index (use correct dimension)
-            
-            
-        except Exception as e:
-            PrettyOutput.print(f"Failed to load embedding model: {str(e)}", OutputType.ERROR)
-            raise
             
         # Initialize methodology related attributes
         self.methodology_data = []
@@ -441,7 +421,6 @@ Strict Rules:
 - Don't create fake dialogues
 - If current information is insufficient, you may ask the user
 - Not all problem-solving steps are mandatory, skip as appropriate
-- Ask user before executing tools that might damage system or user's codebase
 - Request user guidance when multiple iterations show no progress
 - If yaml string contains colons, wrap the entire string in quotes to avoid yaml parsing errors
 - Use | syntax for multi-line strings in yaml
@@ -459,7 +438,7 @@ def main():
 
     try:
         # 获取全局模型实例
-        agent = Agent(system_prompt=origin_agent_system_prompt)
+        agent = Agent(system_prompt=origin_agent_system_prompt, tool_registry=ToolRegistry())
 
         # 加载预定义任务
         tasks = load_tasks()

jarvis/jarvis_code_agent/main.py

@@ -79,8 +79,8 @@ DEVELOPMENT WORKFLOW:
      <TOOL_CALL>
      name: create_code_sub_agent
      arguments:
+         name: code_sub_agent
          subtask: Implement new authentication flow
-         codebase_dir: .
      </TOOL_CALL>
 
 FILE SELECTION WORKFLOW:
@@ -147,10 +147,8 @@ TOOL USAGE:
    - ask_user: Ask user for confirmation and information if needed
    - create_code_sub_agent: Create agent for each small change
    - file_operation: Read files
-   - rag: Ask questions based on a document directory, supporting multiple document formats (txt, pdf, docx, etc.)
    - search: Use Bing search engine to search for information, and extract key information based on the question
    - thinker: Deep thinking and logical reasoning
-
 2. Planning Tools:
    - thinker: Generate a detailed modification plan based on user requirements and actual code conditions.
    - create_code_sub_agent: Create agent for each small change

jarvis/jarvis_coder/patch_handler.py

@@ -211,7 +211,7 @@ class PatchHandler:
                 else:
                     content = "<File does not exist, need to create>"
                     
-                prompt = """You are a senior software development expert who can generate code patches based on the complete modification plan, current original code file path, code content, and current file's modification plan. The output format should be as follows:
+                prompt = """You are a senior software development expert who can generate code patches based on the complete modification plan, current original code file path, code content (with 4-digit hexadecimal line numbers), and current file's modification plan. The output format should be as follows:
 
                 <PATCH>
                 [start,end)
@@ -220,16 +220,16 @@ class PatchHandler:
 
                 Example:
                 <PATCH>
-                [0004,0004)
+                [000c,000c)
                 def new_function():
-    pass
+                    pass
                 </PATCH>
 
                 means:
-                Insert code BEFORE line 4:
+                Insert code BEFORE line 12:
                 ```
                 def new_function():
-    pass
+                    pass
                 ```
                 
                 Example 2:

jarvis/jarvis_github/main.py

@@ -0,0 +1,232 @@
+import os
+import sys
+import argparse
+from typing import Dict, List, Optional
+import yaml
+
+from jarvis.agent import Agent
+from jarvis.utils import PrettyOutput, OutputType, get_single_line_input, init_env
+from jarvis.tools import ToolRegistry
+
+# System prompt for the GitHub workflow agent
+github_workflow_prompt = """You are a GitHub Workflow Agent that helps manage the complete development workflow using GitHub CLI (gh). Follow these steps strictly:
+
+1. Environment Check:
+   - Verify gh CLI installation
+   - Check authentication status
+   - Set up authentication if needed
+
+2. Issue Management:
+   - List and display available issues
+   - Help user select an issue to work on
+   - Analyze the selected issue thoroughly
+
+3. Development Planning:
+   - Create a development branch for the issue
+   - Generate a detailed modification plan
+   - Break down the task into smaller steps
+
+4. Implementation:
+   - Guide through the implementation process
+   - Track changes and progress
+   - Ensure code quality
+
+5. Review and Submit:
+   - Review changes before submission
+   - Create and submit pull request
+   - Handle review feedback
+   - Close the issue upon completion
+
+Always follow GitHub best practices and provide clear feedback at each step.
+"""
+
+def check_gh_installation() -> bool:
+    """Check if GitHub CLI is installed"""
+    return os.system("gh --version > /dev/null 2>&1") == 0
+
+def check_gh_auth() -> bool:
+    """Check if GitHub CLI is authenticated"""
+    return os.system("gh auth status > /dev/null 2>&1") == 0
+
+def setup_gh_auth() -> bool:
+    """Guide user through GitHub CLI authentication"""
+    PrettyOutput.print("Starting GitHub CLI authentication...", OutputType.INFO)
+    return os.system("gh auth login") == 0
+
+def list_issues() -> List[Dict]:
+    """List all available issues"""
+    try:
+        # Get issues in JSON format
+        result = os.popen("gh issue list --json number,title,body,url").read()
+        issues = yaml.safe_load(result)
+        return issues
+    except Exception as e:
+        PrettyOutput.print(f"Error listing issues: {str(e)}", OutputType.ERROR)
+        return []
+
+def select_issue(issues: List[Dict]) -> Optional[Dict]:
+    """Display issues and let user select one"""
+    if not issues:
+        PrettyOutput.print("No issues found.", OutputType.WARNING)
+        return None
+    
+    PrettyOutput.print("\nAvailable Issues:", OutputType.INFO)
+    for i, issue in enumerate(issues, 1):
+        print(f"{i}. #{issue['number']} - {issue['title']}")
+    
+    while True:
+        try:
+            choice = get_single_line_input("\nSelect an issue number (or 0 to exit): ")
+            if not choice or choice == "0":
+                return None
+            
+            index = int(choice) - 1
+            if 0 <= index < len(issues):
+                return issues[index]
+            else:
+                PrettyOutput.print("Invalid selection. Please try again.", OutputType.WARNING)
+        except ValueError:
+            PrettyOutput.print("Please enter a valid number.", OutputType.WARNING)
+
+def create_development_branch(issue_number: int) -> bool:
+    """Create a development branch for the issue"""
+    try:
+        result = os.system(f"gh issue develop {issue_number} --checkout")
+        return result == 0
+    except Exception as e:
+        PrettyOutput.print(f"Error creating branch: {str(e)}", OutputType.ERROR)
+        return False
+
+def create_pull_request(issue_number: int, title: str, body: str) -> bool:
+    """Create a pull request for the changes"""
+    try:
+        cmd = f'gh pr create --title "{title}" --body "{body}" --issue {issue_number}'
+        result = os.system(cmd)
+        return result == 0
+    except Exception as e:
+        PrettyOutput.print(f"Error creating pull request: {str(e)}", OutputType.ERROR)
+        return False
+
+def close_issue(issue_number: int) -> bool:
+    """Close the issue"""
+    try:
+        result = os.system(f"gh issue close {issue_number}")
+        return result == 0
+    except Exception as e:
+        PrettyOutput.print(f"Error closing issue: {str(e)}", OutputType.ERROR)
+        return False
+
+def install_gh_linux() -> bool:
+    """Install GitHub CLI on Linux"""
+    PrettyOutput.print("Installing GitHub CLI...", OutputType.INFO)
+    
+    # Detect package manager
+    package_managers = {
+        "apt": "curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg && \
+                echo \"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main\" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null && \
+                sudo apt update && sudo apt install gh -y",
+        "dnf": "sudo dnf install 'dnf-command(config-manager)' -y && \
+                sudo dnf config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo && \
+                sudo dnf install gh -y",
+        "yum": "sudo yum install 'dnf-command(config-manager)' -y && \
+                sudo yum config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo && \
+                sudo yum install gh -y",
+        "pacman": "sudo pacman -S github-cli --noconfirm",
+    }
+    
+    # Try to detect the package manager
+    for pm, cmd in package_managers.items():
+        if os.system(f"which {pm} > /dev/null 2>&1") == 0:
+            PrettyOutput.print(f"Detected {pm} package manager", OutputType.INFO)
+            if os.system(cmd) == 0:
+                PrettyOutput.print("GitHub CLI installed successfully!", OutputType.SUCCESS)
+                return True
+            else:
+                PrettyOutput.print(f"Failed to install using {pm}", OutputType.ERROR)
+                return False
+    
+    PrettyOutput.print(
+        "Could not detect supported package manager. Please install manually:\n"
+        "https://github.com/cli/cli/blob/trunk/docs/install_linux.md",
+        OutputType.ERROR
+    )
+    return False
+
+def main():
+    """Main entry point for GitHub workflow"""
+    init_env()
+    
+    # Check GitHub CLI installation
+    if not check_gh_installation():
+        if sys.platform.startswith('linux'):
+            if not install_gh_linux():
+                return 1
+        else:
+            PrettyOutput.print(
+                "GitHub CLI (gh) is not installed. Please install it first:\n"
+                "- Windows: winget install GitHub.cli\n"
+                "- macOS: brew install gh\n"
+                "- Linux: See https://github.com/cli/cli/blob/trunk/docs/install_linux.md",
+                OutputType.ERROR
+            )
+            return 1
+    
+    # Check authentication
+    if not check_gh_auth():
+        PrettyOutput.print("GitHub CLI needs authentication.", OutputType.WARNING)
+        if not setup_gh_auth():
+            PrettyOutput.print("Authentication failed. Please try again.", OutputType.ERROR)
+            return 1
+    
+    # List and select issue
+    issues = list_issues()
+    selected_issue = select_issue(issues)
+    if not selected_issue:
+        PrettyOutput.print("No issue selected. Exiting.", OutputType.INFO)
+        return 0
+    
+    # Create GitHub workflow agent
+    tool_registry = ToolRegistry()
+    agent = Agent(
+        system_prompt=github_workflow_prompt,
+        name="GitHub Workflow Agent",
+        tool_registry=tool_registry
+    )
+    
+    # Start the workflow
+    try:
+        # Create development branch
+        if not create_development_branch(selected_issue['number']):
+            return 1
+        
+        # Run the agent with the selected issue
+        workflow_request = f"""
+        Working on issue #{selected_issue['number']}: {selected_issue['title']}
+        
+        Issue description:
+        {selected_issue['body']}
+        
+        Please guide through the development process and help create a pull request.
+        """
+        
+        result = agent.run(workflow_request)
+        
+        # Create pull request and close issue if successful
+        if result and "success" in result.lower():
+            if create_pull_request(
+                selected_issue['number'],
+                f"Fix #{selected_issue['number']}: {selected_issue['title']}",
+                "Implements the requested changes and fixes the issue."
+            ):
+                close_issue(selected_issue['number'])
+                PrettyOutput.print("Workflow completed successfully!", OutputType.SUCCESS)
+                return 0
+    
+    except Exception as e:
+        PrettyOutput.print(f"Error in workflow: {str(e)}", OutputType.ERROR)
+        return 1
+    
+    return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

jarvis/models/ai8.py

@@ -14,6 +14,7 @@ class AI8Model(BasePlatform):
 
     def get_model_list(self) -> List[Tuple[str, str]]:
         """获取模型列表"""
+        self.get_available_models()
         return [(name,info['desc']) for name,info in self.models.items()]
     
     def __init__(self):
@@ -30,9 +31,7 @@ class AI8Model(BasePlatform):
         
         
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
-        if self.model_name not in self.get_available_models():
-            PrettyOutput.print(f"Warning: The selected model {self.model_name} is not in the available list", OutputType.WARNING)
-        
+
 
     def set_model_name(self, model_name: str):
         """Set model name"""

jarvis/models/oyi.py

@@ -14,6 +14,7 @@ class OyiModel(BasePlatform):
 
     def get_model_list(self) -> List[Tuple[str, str]]:
         """Get model list"""
+        self.get_available_models()
         return [(name,info['desc']) for name,info in self.models.items()]
     
     def __init__(self):
@@ -31,9 +32,6 @@ class OyiModel(BasePlatform):
             PrettyOutput.print("OYI_API_KEY is not set", OutputType.WARNING)
         
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
-        if self.model_name not in [m.split()[0] for m in self.get_available_models()]:
-            PrettyOutput.print(f"Warning: The selected model {self.model_name} is not in the available list", OutputType.WARNING)
-        
 
     def set_model_name(self, model_name: str):
         """Set model name"""

jarvis/tools/registry.py

@@ -22,7 +22,6 @@ def load_tools() -> str:
             tools_prompt += f"- Name: {tool['name']}\n"
             tools_prompt += f"  Description: {tool['description']}\n"
             tools_prompt += f"  Parameters: {tool['parameters']}\n"
-            tools_prompt += f"  Usage Format: <TOOL_CALL>\n"
         tools_prompt += """
 Tool Usage Format:
 
@@ -106,48 +105,55 @@ class ToolRegistry:
                 PrettyOutput.print(f"File does not exist: {p_file_path}", OutputType.ERROR)
                 return False
                 
-            # Dynamically import the module
-            module_name = p_file_path.stem
-            spec = importlib.util.spec_from_file_location(module_name, p_file_path) # type: ignore
-            if not spec or not spec.loader:
-                PrettyOutput.print(f"Failed to load module: {p_file_path}", OutputType.ERROR)
-                return False
-                
-            module = importlib.util.module_from_spec(spec) # type: ignore
-            sys.modules[module_name] = module  # Add to sys.modules to support relative imports
-            spec.loader.exec_module(module)
+            # Add the parent directory to sys.path temporarily
+            parent_dir = str(p_file_path.parent)
+            sys.path.insert(0, parent_dir)
             
-            # Find the tool class in the module
-            tool_found = False
-            for item_name in dir(module):
-                item = getattr(module, item_name)
-                # Check if it is a class and has the necessary attributes
-                if (isinstance(item, type) and 
-                    hasattr(item, 'name') and 
-                    hasattr(item, 'description') and 
-                    hasattr(item, 'parameters')):
-                    
-                    # Instantiate the tool class, passing in the model and output processor
-                    tool_instance = item()
-                    
-                    # Register the tool
-                    self.register_tool(
-                        name=tool_instance.name,
-                        description=tool_instance.description,
-                        parameters=tool_instance.parameters,
-                        func=tool_instance.execute
-                    )
-                    tool_found = True
-                    break
+            try:
+                # Import the module using standard import mechanism
+                module_name = p_file_path.stem
+                module = __import__(module_name)
+                
+                # Find the tool class in the module
+                tool_found = False
+                for item_name in dir(module):
+                    item = getattr(module, item_name)
+                    # Check if it is a class and has the necessary attributes
+                    if (isinstance(item, type) and 
+                        hasattr(item, 'name') and 
+                        hasattr(item, 'description') and 
+                        hasattr(item, 'parameters')):
+
+                        if hasattr(item, "check"):
+                            if not item.check():
+                                PrettyOutput.print(f"Tool {item.name} check failed, skipping", OutputType.INFO)
+                                continue
+                        
+                        # Instantiate the tool class
+                        tool_instance = item()
+                        
+                        # Register the tool
+                        self.register_tool(
+                            name=tool_instance.name,
+                            description=tool_instance.description,
+                            parameters=tool_instance.parameters,
+                            func=tool_instance.execute
+                        )
+                        tool_found = True
+                        break
+                        
+                if not tool_found:
+                    PrettyOutput.print(f"No valid tool class found in the file: {p_file_path}", OutputType.INFO)
+                    return False
                     
-            if not tool_found:
-                PrettyOutput.print(f"No valid tool class found in the file: {p_file_path}", OutputType.WARNING)
-                return False
+                return True
+                
+            finally:
+                # Remove the directory from sys.path
+                sys.path.remove(parent_dir)
                 
-            return True
-            
         except Exception as e:
-            PrettyOutput.print(f"Failed to load tool from {p_file_path.name}: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to load tool from {Path(file_path).name}: {str(e)}", OutputType.ERROR)
             return False
 
     def register_tool(self, name: str, description: str, parameters: Dict, func: Callable):
@@ -264,7 +270,9 @@ Please provide a summary:"""
             
             else:
                 PrettyOutput.section("Execution failed", OutputType.WARNING)
-                
+            
+            if len(tool_calls) > 1:
+                output += f"\n\n--- 一次只能执行一个工具, 因此以下工具未执行\n{str(tool_calls[1:])} ---"
             return output
             
         except Exception as e:

jarvis/utils.py

@@ -1,4 +1,3 @@
-from ast import List, Str
 import hashlib
 from pathlib import Path
 import sys
@@ -6,18 +5,14 @@ import time
 import os
 from enum import Enum
 from datetime import datetime
-from typing import Any, Dict
+from typing import Any
 import colorama
 from colorama import Fore, Style as ColoramaStyle
 import numpy as np
 from prompt_toolkit import PromptSession
 from prompt_toolkit.styles import Style as PromptStyle
 from prompt_toolkit.formatted_text import FormattedText
-from sentence_transformers import SentenceTransformer
-from transformers import AutoModelForSequenceClassification, AutoTokenizer
-import torch
 import yaml
-import faiss
 
 # 初始化colorama
 colorama.init()
@@ -244,70 +239,6 @@ def find_git_root(dir="."):
     os.chdir(curr_dir)
     return ret
 
-def load_embedding_model():
-    model_name = "BAAI/bge-m3"
-    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
-    
-
-    try:
-        # Load model
-        embedding_model = SentenceTransformer(
-            model_name,
-            cache_folder=cache_dir,
-            local_files_only=True
-        )
-    except Exception as e:
-        PrettyOutput.print(f"Failed to load embedding model: {str(e)}", OutputType.ERROR)
-        os.system(f'huggingface-cli download --repo-type model --local-dir {cache_dir} {model_name}')
-        # Load model
-        embedding_model = SentenceTransformer(
-            model_name,
-            cache_folder=cache_dir,
-            local_files_only=True
-        )
-    
-    return embedding_model
-
-def load_rerank_model():
-    """Load reranking model"""
-    model_name = "BAAI/bge-reranker-v2-m3"
-    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
-    
-    PrettyOutput.print(f"Loading reranking model: {model_name}...", OutputType.INFO)
-    
-    try:
-        # Load model and tokenizer
-        tokenizer = AutoTokenizer.from_pretrained(
-            model_name,
-            cache_dir=cache_dir,
-            local_files_only=True
-        )
-        model = AutoModelForSequenceClassification.from_pretrained(
-            model_name,
-            cache_dir=cache_dir,
-            local_files_only=True
-        )
-    except Exception as e:
-        PrettyOutput.print(f"Failed to load reranking model: {str(e)}", OutputType.ERROR)
-        os.system(f'huggingface-cli download --repo-type model --local-dir {cache_dir} {model_name}')
-        # Load model and tokenizer
-        tokenizer = AutoTokenizer.from_pretrained(
-            model_name,
-            cache_dir=cache_dir,
-            local_files_only=True
-        )
-        model = AutoModelForSequenceClassification.from_pretrained(
-            model_name,
-            cache_dir=cache_dir,
-            local_files_only=True
-        )
-    
-    # Use GPU if available
-    if torch.cuda.is_available():
-        model = model.cuda()
-    model.eval()
-    
-    return model, tokenizer
 
 def get_max_context_length():
     return int(os.getenv('JARVIS_MAX_CONTEXT_LENGTH', '131072'))  # 默认128k
@@ -359,7 +290,6 @@ def _create_methodology_embedding(embedding_model: Any, methodology_text: str) -
 
 def load_methodology(user_input: str) -> str:
     """Load methodology and build vector index"""
-    PrettyOutput.print("Loading methodology...", OutputType.PROGRESS)
     user_jarvis_methodology = os.path.expanduser("~/.jarvis/methodology")
     if not os.path.exists(user_jarvis_methodology):
         return ""
@@ -368,62 +298,17 @@ def load_methodology(user_input: str) -> str:
         with open(user_jarvis_methodology, "r", encoding="utf-8") as f:
             data = yaml.safe_load(f)
 
-        # Reset data structure
-        methodology_data = []
-        vectors = []
-        ids = []
-
-        # Get embedding model
-        embedding_model = load_embedding_model()
         
-        # Create test embedding to get correct dimension
-        test_embedding = _create_methodology_embedding(embedding_model, "test")
-        embedding_dimension = len(test_embedding)
-
-        # Create embedding vector for each methodology
-        for i, (key, value) in enumerate(data.items()):
-            PrettyOutput.print(f"Vectorizing methodology: {key} ...", OutputType.INFO)
-            methodology_text = f"{key}\n{value}"
-            embedding = _create_methodology_embedding(embedding_model, methodology_text)
-            vectors.append(embedding)
-            ids.append(i)
-            methodology_data.append({"key": key, "value": value})
-
-        if vectors:
-            vectors_array = np.vstack(vectors)
-            # Use correct dimension from test embedding
-            hnsw_index = faiss.IndexHNSWFlat(embedding_dimension, 16)
-            hnsw_index.hnsw.efConstruction = 40
-            hnsw_index.hnsw.efSearch = 16
-            methodology_index = faiss.IndexIDMap(hnsw_index)
-            methodology_index.add_with_ids(vectors_array, np.array(ids)) # type: ignore
-            query_embedding = _create_methodology_embedding(embedding_model, user_input)
-            k = min(5, len(methodology_data))
-            PrettyOutput.print(f"Retrieving methodology...", OutputType.INFO)
-            distances, indices = methodology_index.search(
-                query_embedding.reshape(1, -1), k
-            ) # type: ignore
-
-            relevant_methodologies = {}
-            for dist, idx in zip(distances[0], indices[0]):
-                if idx >= 0:
-                    similarity = 1.0 / (1.0 + float(dist))
-                    methodology = methodology_data[idx]
-                    PrettyOutput.print(
-                        f"Methodology '{methodology['key']}' similarity: {similarity:.3f}",
-                        OutputType.INFO
-                    )
-                    if similarity >= 0.5:
-                        relevant_methodologies[methodology["key"]] = methodology["value"]
-                    
-            if relevant_methodologies:
-                return f"""This is the standard methodology for handling previous problems, if the current task is similar, you can refer to it:
-                        {relevant_methodologies}
-                        """
-        return ""
+        ret = """This is the standard methodology for handling previous problems, if the current task is similar, you can refer to it:"""
+        for k, v in data.items():
+            ret += f"\n{k}: {v}\n"
+        return ret
 
     except Exception as e:
         PrettyOutput.print(f"Error loading methodology: {str(e)}", OutputType.ERROR)
         import traceback
         PrettyOutput.print(f"Error trace: {traceback.format_exc()}", OutputType.INFO)
-        return ""
+        return ""
+    
+def no_embedding() -> bool:
+    return bool(os.environ.get("JARVIS_NO_EMBEDDING", ""))