open-swarm 0.1.1743070217__py3-none-any.whl

swarm/extensions/cli/selection.py

@@ -0,0 +1,43 @@
+from typing import Dict, Optional, Any
+from swarm.utils.color_utils import color_text
+import logging
+
+# Configure logger
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+def prompt_user_to_select_blueprint(blueprints_metadata: Dict[str, Dict[str, Any]]) -> Optional[str]:
+    """
+    Allow the user to select a blueprint from available options.
+
+    Args:
+        blueprints_metadata (Dict[str, Dict[str, Any]]): Metadata of available blueprints.
+
+    Returns:
+        Optional[str]: Selected blueprint name, or None if no selection is made.
+    """
+    if not blueprints_metadata:
+        logger.warning("No blueprints available. Blueprint selection skipped.")
+        print(color_text("No blueprints available. Please add blueprints to continue.", "yellow"))
+        return None  # Updated to remove 'default blueprint'
+
+    print("\nAvailable Blueprints:")
+    for idx, (key, metadata) in enumerate(blueprints_metadata.items(), start=1):
+        print(f"{idx}. {metadata.get('title', key)} - {metadata.get('description', 'No description available')}")
+
+    while True:
+        try:
+            choice = int(input("\nEnter the number of the blueprint you want to run (0 to cancel): "))
+            if choice == 0:
+                logger.info("User chose to cancel blueprint selection.")
+                return None  # Explicitly return None when selection is canceled
+            elif 1 <= choice <= len(blueprints_metadata):
+                selected_key = list(blueprints_metadata.keys())[choice - 1]
+                logger.info(f"User selected blueprint: '{selected_key}'")
+                return selected_key
+            else:
+                print(f"Please enter a number between 0 and {len(blueprints_metadata)}.")
+                logger.warning(f"User entered invalid blueprint number: {choice}")
+        except ValueError:
+            print("Invalid input. Please enter a valid number.")
+            logger.warning("User entered non-integer value for blueprint selection.")

swarm/extensions/cli/utils/discover_commands.py

@@ -0,0 +1,32 @@
+"""
+Utility to discover and load CLI commands dynamically.
+"""
+
+import os
+import importlib.util
+
+def discover_commands(commands_dir):
+    """
+    Discover all commands in the given directory.
+
+    Args:
+        commands_dir (str): Path to the commands directory.
+
+    Returns:
+        dict: A dictionary of commands with metadata.
+    """
+    commands = {}
+    for filename in os.listdir(commands_dir):
+        if filename.endswith(".py") and filename != "__init__.py":
+            module_name = f"swarm.extensions.cli.commands.{filename[:-3]}"
+            spec = importlib.util.find_spec(module_name)
+            if not spec:
+                continue
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            commands[module_name] = {
+                "description": getattr(module, "description", "No description provided."),
+                "usage": getattr(module, "usage", "No usage available."),
+                "execute": getattr(module, "execute", None),
+            }
+    return commands

swarm/extensions/cli/utils/env_setup.py

@@ -0,0 +1,15 @@
+# Handles .env management and environment validation for the CLI
+
+import os
+from dotenv import load_dotenv
+
+def validate_env():
+    """Ensure all required environment variables are set."""
+    load_dotenv()
+    required_vars = ["API_KEY", "MCP_SERVER"]
+    missing = [var for var in required_vars if not os.getenv(var)]
+    if missing:
+        print(f"Missing required environment variables: {', '.join(missing)}")
+        return False
+    print("Environment validation passed.")
+    return True

swarm/extensions/cli/utils.py

@@ -0,0 +1,105 @@
+import logging
+import sys
+from typing import Dict, Optional
+from swarm.utils.color_utils import color_text
+
+import os
+
+logger = logging.getLogger(__name__)
+
+def find_project_root(current_path: str, marker: str = ".git") -> str:
+    """
+    Recursively search for the project root by looking for a specific marker file or directory.
+
+    Args:
+        current_path (str): Starting path for the search.
+        marker (str): Marker file or directory to identify the project root.
+
+    Returns:
+        str: Path to the project root.
+
+    Raises:
+        FileNotFoundError: If the project root cannot be found.
+    """
+    while True:
+        if os.path.exists(os.path.join(current_path, marker)):
+            return current_path
+        new_path = os.path.dirname(current_path)
+        if new_path == current_path:
+            break
+        current_path = new_path
+    logger.error(f"Project root with marker '{marker}' not found.")
+    raise FileNotFoundError(f"Project root with marker '{marker}' not found.")
+
+def display_message(message: str, message_type: str = "info") -> None:
+    """
+    Display a message to the user with optional color formatting.
+
+    Args:
+        message (str): The message to display.
+        message_type (str): The type of message (info, warning, error).
+    """
+    color_map = {
+        "info": "cyan",
+        "warning": "yellow",
+        "error": "red"
+    }
+    color = color_map.get(message_type, "cyan")
+    print(color_text(message, color))
+    if message_type == "error":
+        logger.error(message)
+    elif message_type == "warning":
+        logger.warning(message)
+    else:
+        logger.info(message)
+
+def prompt_user(prompt: str, default: Optional[str] = None) -> str:
+    """
+    Prompt the user for input with an optional default value.
+
+    Args:
+        prompt (str): The prompt to display to the user.
+        default (Optional[str]): The default value to use if the user provides no input.
+
+    Returns:
+        str: The user's input or the default value.
+    """
+    if default:
+        prompt = f"{prompt} [{default}]: "
+    else:
+        prompt = f"{prompt}: "
+    user_input = input(prompt).strip()
+    return user_input or default
+
+def validate_input(user_input: str, valid_options: list, default: Optional[str] = None) -> str:
+    """
+    Validate the user's input against a list of valid options.
+
+    Args:
+        user_input (str): The user's input.
+        valid_options (list): A list of valid options.
+        default (Optional[str]): A default value to use if the input is invalid.
+
+    Returns:
+        str: The valid input or the default value.
+    """
+    if user_input in valid_options:
+        return user_input
+    elif default is not None:
+        display_message(f"Invalid input. Using default: {default}", "warning")
+        return default
+    else:
+        display_message(f"Invalid input. Valid options are: {', '.join(valid_options)}", "error")
+        raise ValueError(f"Invalid input: {user_input}")
+
+def log_and_exit(message: str, code: int = 1) -> None:
+    """
+    Log an error message and exit the application.
+
+    Args:
+        message (str): The error message to log.
+        code (int): The exit code to use.
+    """
+    logger.error(message)
+    display_message(message, "error")
+    sys.exit(code)

swarm/extensions/config/__init__.py

@@ -0,0 +1,6 @@
+# src/swarm/config/__init__.py
+
+"""
+Configuration module for Open Swarm MCP.
+Handles loading, validating, and setting up configurations.
+"""

swarm/extensions/config/config_loader.py

@@ -0,0 +1,208 @@
+"""
+Configuration Loader for Open Swarm MCP Framework.
+"""
+
+import os
+import json
+import re
+import logging
+from typing import Any, Dict, List, Tuple, Optional
+from pathlib import Path
+from dotenv import load_dotenv
+try: from .server_config import save_server_config
+except ImportError: save_server_config = None
+
+SWARM_DEBUG = os.getenv("SWARM_DEBUG", "False").lower() in ("true", "1", "yes")
+try: from swarm.settings import BASE_DIR
+except ImportError: BASE_DIR = Path(__file__).resolve().parent.parent.parent
+
+from swarm.utils.redact import redact_sensitive_data
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG if SWARM_DEBUG else logging.INFO)
+
+# Add handler only if needed, DO NOT set handler level conditionally here
+if not logger.handlers and not logging.getLogger().hasHandlers():
+    stream_handler = logging.StreamHandler()
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s:%(lineno)d - %(message)s")
+    stream_handler.setFormatter(formatter)
+    logger.addHandler(stream_handler)
+    # --- REMOVED CONDITIONAL HANDLER LEVEL SETTING ---
+    # if not SWARM_DEBUG:
+    #     stream_handler.setLevel(logging.WARNING)
+
+config: Dict[str, Any] = {}
+load_dotenv()
+logger.debug("Environment variables potentially loaded from .env file.")
+
+def process_config(config_dict: dict) -> dict:
+    """Processes config: resolves placeholders, merges external MCP."""
+    try:
+        resolved_config = resolve_placeholders(config_dict)
+        if logger.isEnabledFor(logging.DEBUG): logger.debug("Config after resolving placeholders: " + json.dumps(redact_sensitive_data(resolved_config), indent=2))
+        disable_merge = os.getenv("DISABLE_MCP_MERGE", "false").lower() in ("true", "1", "yes")
+        if not disable_merge:
+            if os.name == "nt": external_mcp_path = Path(os.getenv("APPDATA", Path.home())) / "Claude" / "claude_desktop_config.json"
+            else: external_mcp_path = Path.home() / ".vscode-server" / "data" / "User" / "globalStorage" / "rooveterinaryinc.roo-cline" / "settings" / "cline_mcp_settings.json"
+            if external_mcp_path.exists():
+                logger.info(f"Found external MCP settings file at: {external_mcp_path}")
+                try:
+                    with open(external_mcp_path, "r", encoding='utf-8') as mcp_file: external_mcp_config = json.load(mcp_file)
+                    if logger.isEnabledFor(logging.DEBUG): logger.debug("Loaded external MCP settings: " + json.dumps(redact_sensitive_data(external_mcp_config), indent=2))
+                    main_mcp_servers = resolved_config.get("mcpServers", {}); external_mcp_servers = external_mcp_config.get("mcpServers", {})
+                    merged_mcp_servers = main_mcp_servers.copy(); servers_added_count = 0
+                    for name, server_cfg in external_mcp_servers.items():
+                        if name not in merged_mcp_servers and not server_cfg.get("disabled", False): merged_mcp_servers[name] = server_cfg; servers_added_count += 1
+                    if servers_added_count > 0: resolved_config["mcpServers"] = merged_mcp_servers; logger.info(f"Merged {servers_added_count} MCP servers.");
+                    else: logger.debug("No new MCP servers added from external settings.")
+                except Exception as merge_err: logger.error(f"Failed to load/merge MCP settings from '{external_mcp_path}': {merge_err}", exc_info=logger.isEnabledFor(logging.DEBUG))
+            else: logger.debug(f"External MCP settings file not found at {external_mcp_path}. Skipping merge.")
+        else: logger.debug("MCP settings merge disabled.")
+    except Exception as e: logger.error(f"Failed during config processing: {e}", exc_info=logger.isEnabledFor(logging.DEBUG)); raise
+    globals()["config"] = resolved_config
+    return resolved_config
+
+def resolve_placeholders(obj: Any) -> Any:
+    """Recursively resolve ${VAR_NAME} placeholders."""
+    if isinstance(obj, dict): return {k: resolve_placeholders(v) for k, v in obj.items()}
+    elif isinstance(obj, list): return [resolve_placeholders(item) for item in obj]
+    elif isinstance(obj, str):
+        pattern = re.compile(r'\$\{(\w+(?:[_-]\w+)*)\}')
+        resolved_string = obj; any_unresolved = False
+        for var_name in pattern.findall(obj):
+            env_value = os.getenv(var_name); placeholder = f'${{{var_name}}}'
+            if env_value is None:
+                log_level = logging.DEBUG
+                if resolved_string == placeholder:
+                     log_level = logging.WARNING
+                     resolved_string = None
+                     any_unresolved = True
+                     logger.log(log_level, f"Env var '{var_name}' not set for placeholder '{placeholder}'. Resolving to None.")
+                     return None
+                else:
+                    resolved_string = resolved_string.replace(placeholder, "")
+                    any_unresolved = True
+                    logger.log(log_level, f"Env var '{var_name}' not set for placeholder '{placeholder}'. Removing from string.")
+            else:
+                 resolved_string = resolved_string.replace(placeholder, env_value)
+                 if logger.isEnabledFor(logging.DEBUG): logger.debug(f"Resolved placeholder '{placeholder}' using env var '{var_name}'.")
+        if any_unresolved and resolved_string is not None:
+             logger.debug(f"String '{obj}' contained unresolved placeholders. Result: '{resolved_string}'")
+        return resolved_string
+    else: return obj
+
+def load_server_config(file_path: Optional[str] = None) -> dict:
+    """Loads, resolves, and merges server config from JSON file."""
+    config_path: Optional[Path] = None
+    if file_path:
+         path_obj = Path(file_path)
+         if path_obj.is_file(): config_path = path_obj; logger.info(f"Using provided config file path: {config_path}")
+         else: logger.warning(f"Provided path '{file_path}' not found. Searching standard locations.")
+    if not config_path:
+        standard_paths = [ Path.cwd() / "swarm_config.json", Path(BASE_DIR) / "swarm_config.json", Path.home() / ".swarm" / "swarm_config.json" ]
+        config_path = next((p for p in standard_paths if p.is_file()), None)
+        if not config_path: raise FileNotFoundError(f"Config file 'swarm_config.json' not found. Checked: {[str(p) for p in standard_paths]}")
+        logger.info(f"Using config file found at: {config_path}")
+    try:
+        raw_config = json.loads(config_path.read_text(encoding='utf-8'))
+        if logger.isEnabledFor(logging.DEBUG): logger.debug(f"Raw config loaded: {redact_sensitive_data(raw_config)}")
+        processed_config = process_config(raw_config)
+        globals()["config"] = processed_config
+        logger.info(f"Config loaded and processed from {config_path}")
+        return processed_config
+    except json.JSONDecodeError as e: logger.critical(f"Invalid JSON in {config_path}: {e}"); raise ValueError(f"Invalid JSON") from e
+    except Exception as e: logger.critical(f"Failed to read/process config {config_path}: {e}"); raise ValueError("Failed to load/process config") from e
+
+def load_llm_config(config_dict: Optional[Dict[str, Any]] = None, llm_name: Optional[str] = None) -> Dict[str, Any]:
+    """Loads, validates, and resolves API keys for a specific LLM profile."""
+    if config_dict is None:
+        global_config = globals().get("config")
+        if not global_config:
+             try: config_dict = load_server_config(); globals()["config"] = config_dict
+             except Exception as e: raise ValueError("Global config not loaded and no config_dict provided.") from e
+        else: config_dict = global_config
+
+    target_llm_name = llm_name or os.getenv("DEFAULT_LLM", "default")
+    logger.debug(f"LOAD_LLM: Loading profile: '{target_llm_name}'.")
+
+    resolved_config = resolve_placeholders(config_dict)
+    llm_profiles = resolved_config.get("llm", {})
+    if not isinstance(llm_profiles, dict): raise ValueError("'llm' section must be a dictionary.")
+
+    llm_config = llm_profiles.get(target_llm_name)
+    config_source = f"config file ('{target_llm_name}')"
+    logger.debug(f"LOAD_LLM: Initial lookup for '{target_llm_name}': {'Found' if llm_config else 'Missing'}")
+
+    if not llm_config:
+        logger.warning(f"LOAD_LLM: Config for '{target_llm_name}' not found. Generating fallback.")
+        config_source = "fallback generation"
+        fb_provider = os.getenv("DEFAULT_LLM_PROVIDER", "openai"); fb_model = os.getenv("DEFAULT_LLM_MODEL", "gpt-4o")
+        llm_config = { "provider": fb_provider, "model": fb_model, "api_key": None, "base_url": None }
+        logger.debug(f"LOAD_LLM: Generated fallback core config: {llm_config}")
+
+    if not isinstance(llm_config, dict): raise ValueError(f"LLM profile '{target_llm_name}' must be a dictionary.")
+
+    final_api_key = llm_config.get("api_key"); key_log_source = f"{config_source} (resolved)" if final_api_key else config_source
+    provider = llm_config.get("provider"); api_key_required = llm_config.get("api_key_required", True)
+    logger.debug(f"LOAD_LLM: Initial key from {key_log_source}: {'****' if final_api_key else 'None'}. Required={api_key_required}")
+
+    logger.debug(f"LOAD_LLM: Checking ENV vars for potential override.")
+    specific_env_var_name = f"{provider.upper()}_API_KEY" if provider else "PROVIDER_API_KEY"
+    common_fallback_var = "OPENAI_API_KEY"
+    specific_key_from_env = os.getenv(specific_env_var_name); fallback_key_from_env = os.getenv(common_fallback_var)
+    logger.debug(f"LOAD_LLM: Env Check: Specific ('{specific_env_var_name}')={'****' if specific_key_from_env else 'None'}, Fallback ('{common_fallback_var}')={'****' if fallback_key_from_env else 'None'}")
+
+    if specific_key_from_env:
+        if final_api_key != specific_key_from_env: logger.info(f"LOAD_LLM: Overriding key with env var '{specific_env_var_name}'.")
+        final_api_key = specific_key_from_env; key_log_source = f"env var '{specific_env_var_name}'"
+    elif fallback_key_from_env:
+        if not specific_key_from_env or specific_env_var_name == common_fallback_var:
+            if final_api_key != fallback_key_from_env: logger.info(f"LOAD_LLM: Overriding key with fallback env var '{common_fallback_var}'.")
+            final_api_key = fallback_key_from_env; key_log_source = f"env var '{common_fallback_var}'"
+        else: logger.debug(f"LOAD_LLM: Specific env key '{specific_env_var_name}' unset, NOT using fallback.")
+    else: logger.debug(f"LOAD_LLM: No relevant API key found in environment variables.")
+
+    key_is_still_missing_or_empty = final_api_key is None or (isinstance(final_api_key, str) and not final_api_key.strip())
+    logger.debug(f"LOAD_LLM: Key after env check: {'****' if final_api_key else 'None'}. Source: {key_log_source}. Still MissingOrEmpty={key_is_still_missing_or_empty}")
+
+    if key_is_still_missing_or_empty:
+        if api_key_required and not os.getenv("SUPPRESS_DUMMY_KEY"):
+             final_api_key = "sk-DUMMYKEY"; key_log_source = "dummy key"; logger.warning(f"LOAD_LLM: Applying dummy key for '{target_llm_name}'.")
+        elif api_key_required:
+             key_log_source = "MISSING - ERROR"; raise ValueError(f"Required API key for LLM profile '{target_llm_name}' is missing.")
+        else: key_log_source = "Not Required/Not Found"
+
+    final_llm_config = llm_config.copy(); final_llm_config["api_key"] = final_api_key; final_llm_config["_log_key_source"] = key_log_source
+    logger.debug(f"LOAD_LLM: Returning final config for '{target_llm_name}': {redact_sensitive_data(final_llm_config)}")
+    return final_llm_config
+
+def get_llm_model(config_dict: Dict[str, Any], llm_name: Optional[str] = None) -> str:
+    target_llm_name = llm_name or os.getenv("DEFAULT_LLM", "default")
+    try: llm_config = load_llm_config(config_dict, target_llm_name)
+    except ValueError as e: raise ValueError(f"Could not load config for LLM '{target_llm_name}': {e}") from e
+    model_name = llm_config.get("model")
+    if not model_name or not isinstance(model_name, str): raise ValueError(f"'model' name missing/invalid for LLM '{target_llm_name}'.")
+    logger.debug(f"Retrieved model name '{model_name}' for LLM '{target_llm_name}'")
+    return model_name
+
+def load_and_validate_llm(config_dict: Dict[str, Any], llm_name: Optional[str] = None) -> Dict[str, Any]:
+    target_llm_name = llm_name or os.getenv("DEFAULT_LLM", "default")
+    logger.debug(f"Loading and validating LLM (via load_llm_config) for profile: {target_llm_name}")
+    return load_llm_config(config_dict, target_llm_name)
+
+def get_server_params(server_config: Dict[str, Any], server_name: str) -> Optional[Dict[str, Any]]:
+    """Extracts and validates parameters needed to start an MCP server."""
+    command = server_config.get("command"); args = server_config.get("args", []); config_env = server_config.get("env", {})
+    if not command: logger.error(f"MCP server '{server_name}' missing 'command'."); return None
+    if not isinstance(args, list): logger.error(f"MCP server '{server_name}' 'args' must be list."); return None
+    if not isinstance(config_env, dict): logger.error(f"MCP server '{server_name}' 'env' must be dict."); return None
+    env = {**os.environ.copy(), **config_env}; valid_env = {}
+    for k, v in env.items():
+        if v is None: logger.warning(f"Env var '{k}' for MCP server '{server_name}' resolved to None. Omitting.")
+        else: valid_env[k] = str(v)
+    return {"command": command, "args": args, "env": valid_env}
+
+def list_mcp_servers(config_dict: Dict[str, Any]) -> List[str]:
+     """Returns a list of configured MCP server names."""
+     return list(config_dict.get("mcpServers", {}).keys())
+

swarm/extensions/config/config_manager.py

@@ -0,0 +1,258 @@
+# src/swarm/extensions/config/config_manager.py
+
+import json
+import shutil
+import sys
+import logging
+from typing import Any, Dict
+
+from swarm.extensions.config.config_loader import (
+    load_server_config,
+    resolve_placeholders
+)
+from swarm.utils.color_utils import color_text
+from swarm.settings import DEBUG
+from swarm.extensions.cli.utils import (
+    prompt_user,
+    log_and_exit,
+    display_message
+)
+
+# Initialize logger for this module
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG if DEBUG else logging.INFO)
+if not logger.handlers:
+    stream_handler = logging.StreamHandler()
+    formatter = logging.Formatter("[%(levelname)s] %(asctime)s - %(name)s - %(message)s")
+    stream_handler.setFormatter(formatter)
+    logger.addHandler(stream_handler)
+
+CONFIG_BACKUP_SUFFIX = ".backup"
+
+def backup_configuration(config_path: str) -> None:
+    """
+    Create a backup of the existing configuration file.
+
+    Args:
+        config_path (str): Path to the configuration file.
+    """
+    backup_path = config_path + CONFIG_BACKUP_SUFFIX
+    try:
+        shutil.copy(config_path, backup_path)
+        logger.info(f"Configuration backup created at '{backup_path}'")
+        display_message(f"Backup of configuration created at '{backup_path}'", "info")
+    except Exception as e:
+        logger.error(f"Failed to create configuration backup: {e}")
+        display_message(f"Failed to create backup: {e}", "error")
+        sys.exit(1)
+
+def load_config(config_path: str) -> Dict[str, Any]:
+    """
+    Load the server configuration from a JSON file and resolve placeholders.
+
+    Args:
+        config_path (str): Path to the configuration file.
+
+    Returns:
+        Dict[str, Any]: The resolved configuration.
+
+    Raises:
+        FileNotFoundError: If the configuration file does not exist.
+        ValueError: If the file contains invalid JSON or unresolved placeholders.
+    """
+    try:
+        with open(config_path, "r") as file:
+            config = json.load(file)
+            logger.debug(f"Raw configuration loaded: {config}")
+    except FileNotFoundError:
+        logger.error(f"Configuration file not found at {config_path}")
+        display_message(f"Configuration file not found at {config_path}", "error")
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        logger.error(f"Invalid JSON in configuration file {config_path}: {e}")
+        display_message(f"Invalid JSON in configuration file {config_path}: {e}", "error")
+        sys.exit(1)
+
+    # Resolve placeholders recursively
+    try:
+        resolved_config = resolve_placeholders(config)
+        logger.debug(f"Configuration after resolving placeholders: {resolved_config}")
+    except Exception as e:
+        logger.error(f"Failed to resolve placeholders in configuration: {e}")
+        display_message(f"Failed to resolve placeholders in configuration: {e}", "error")
+        sys.exit(1)
+
+    return resolved_config
+
+def save_config(config_path: str, config: Dict[str, Any]) -> None:
+    """
+    Save the updated configuration to the config file.
+
+    Args:
+        config_path (str): Path to the configuration file.
+        config (Dict[str, Any]): Configuration dictionary to save.
+
+    Raises:
+        SystemExit: If saving the configuration fails.
+    """
+    try:
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=4)
+        logger.info(f"Configuration saved to '{config_path}'")
+        display_message(f"Configuration saved to '{config_path}'", "info")
+    except Exception as e:
+        logger.error(f"Failed to save configuration: {e}")
+        display_message(f"Failed to save configuration: {e}", "error")
+        sys.exit(1)
+
+def add_llm(config_path: str) -> None:
+    """
+    Add a new LLM to the configuration.
+
+    Args:
+        config_path (str): Path to the configuration file.
+    """
+    config = load_config(config_path)
+    display_message("Starting the process to add a new LLM.", "info")
+
+    while True:
+        llm_name = prompt_user("Enter the name of the new LLM (or type 'done' to finish)").strip()
+        display_message(f"User entered LLM name: {llm_name}", "info")
+        if llm_name.lower() == 'done':
+            display_message("Finished adding LLMs.", "info")
+            break
+        if not llm_name:
+            display_message("LLM name cannot be empty.", "error")
+            continue
+
+        if llm_name in config.get("llm", {}):
+            display_message(f"LLM '{llm_name}' already exists.", "warning")
+            continue
+
+        llm = {}
+        llm["provider"] = prompt_user("Enter the provider type (e.g., 'openai', 'ollama')").strip()
+        llm["model"] = prompt_user("Enter the model name (e.g., 'gpt-4')").strip()
+        llm["base_url"] = prompt_user("Enter the base URL for the API").strip()
+        llm_api_key_input = prompt_user("Enter the environment variable for the API key (e.g., 'OPENAI_API_KEY') or leave empty if not required").strip()
+        if llm_api_key_input:
+            llm["api_key"] = f"${{{llm_api_key_input}}}"
+        else:
+            llm["api_key"] = ""
+        try:
+            temperature_input = prompt_user("Enter the temperature (e.g., 0.7)").strip()
+            llm["temperature"] = float(temperature_input)
+        except ValueError:
+            display_message("Invalid temperature value. Using default 0.7.", "warning")
+            llm["temperature"] = 0.7
+
+        config.setdefault("llm", {})[llm_name] = llm
+        logger.info(f"Added LLM '{llm_name}' to configuration.")
+        display_message(f"LLM '{llm_name}' added.", "info")
+
+    backup_configuration(config_path)
+    save_config(config_path, config)
+    display_message("LLM configuration process completed.", "info")
+
+def remove_llm(config_path: str, llm_name: str) -> None:
+    """
+    Remove an existing LLM from the configuration.
+
+    Args:
+        config_path (str): Path to the configuration file.
+        llm_name (str): Name of the LLM to remove.
+    """
+    config = load_config(config_path)
+
+    if llm_name not in config.get("llm", {}):
+        display_message(f"LLM '{llm_name}' does not exist.", "error")
+        return
+
+    confirm = prompt_user(f"Are you sure you want to remove LLM '{llm_name}'? (yes/no)").strip().lower()
+    if confirm not in ['yes', 'y']:
+        display_message("Operation cancelled.", "warning")
+        return
+
+    del config["llm"][llm_name]
+    backup_configuration(config_path)
+    save_config(config_path, config)
+    display_message(f"LLM '{llm_name}' has been removed.", "info")
+    logger.info(f"Removed LLM '{llm_name}' from configuration.")
+
+def add_mcp_server(config_path: str) -> None:
+    """
+    Add a new MCP server to the configuration.
+
+    Args:
+        config_path (str): Path to the configuration file.
+    """
+    config = load_config(config_path)
+    display_message("Starting the process to add a new MCP server.", "info")
+
+    while True:
+        server_name = prompt_user("Enter the name of the new MCP server (or type 'done' to finish)").strip()
+        display_message(f"User entered MCP server name: {server_name}", "info")
+        if server_name.lower() == 'done':
+            display_message("Finished adding MCP servers.", "info")
+            break
+        if not server_name:
+            display_message("Server name cannot be empty.", "error")
+            continue
+
+        if server_name in config.get("mcpServers", {}):
+            display_message(f"MCP server '{server_name}' already exists.", "warning")
+            continue
+
+        server = {}
+        server["command"] = prompt_user("Enter the command to run the MCP server (e.g., 'npx', 'uvx')").strip()
+        args_input = prompt_user("Enter the arguments as a JSON array (e.g., [\"-y\", \"server-name\"])").strip()
+        try:
+            server["args"] = json.loads(args_input)
+            if not isinstance(server["args"], list):
+                raise ValueError
+        except ValueError:
+            display_message("Invalid arguments format. Using an empty list.", "warning")
+            server["args"] = []
+
+        env_vars = {}
+        add_env = prompt_user("Do you want to add environment variables? (yes/no)").strip().lower()
+        while add_env in ['yes', 'y']:
+            env_var = prompt_user("Enter the environment variable name").strip()
+            env_value = prompt_user(f"Enter the value or placeholder for '{env_var}' (e.g., '${{{env_var}_KEY}}')").strip()
+            if env_var and env_value:
+                env_vars[env_var] = env_value
+            add_env = prompt_user("Add another environment variable? (yes/no)").strip().lower()
+
+        server["env"] = env_vars
+
+        config.setdefault("mcpServers", {})[server_name] = server
+        logger.info(f"Added MCP server '{server_name}' to configuration.")
+        display_message(f"MCP server '{server_name}' added.", "info")
+
+    backup_configuration(config_path)
+    save_config(config_path, config)
+    display_message("MCP server configuration process completed.", "info")
+
+def remove_mcp_server(config_path: str, server_name: str) -> None:
+    """
+    Remove an existing MCP server from the configuration.
+
+    Args:
+        config_path (str): Path to the configuration file.
+        server_name (str): Name of the MCP server to remove.
+    """
+    config = load_config(config_path)
+
+    if server_name not in config.get("mcpServers", {}):
+        display_message(f"MCP server '{server_name}' does not exist.", "error")
+        return
+
+    confirm = prompt_user(f"Are you sure you want to remove MCP server '{server_name}'? (yes/no)").strip().lower()
+    if confirm not in ['yes', 'y']:
+        display_message("Operation cancelled.", "warning")
+        return
+
+    del config["mcpServers"][server_name]
+    backup_configuration(config_path)
+    save_config(config_path, config)
+    display_message(f"MCP server '{server_name}' has been removed.", "info")
+    logger.info(f"Removed MCP server '{server_name}' from configuration.")