Refactor Docker Launch Method for MindSearch (#185)

* Build a mindsearch docker launcher with Python

* chore: Update Docker Compose configuration and dependencies for mindsearch docker launcher

* chore: Add copy_frontend_dockerfile method to copy the frontend Dockerfile

* chore: Refactor Dockerfile copying logic and update Docker Compose configuration

* chore: Update Docker Compose configuration to use internlm_server as the default model format

* Refactor Docker Compose configuration and Dockerfile copying logic

* chore: Update Docker Compose configuration and Dockerfile copying logic

* chore: Update Docker Compose configuration and Dockerfile copying logic

* Refactor Docker Compose configuration and Dockerfile copying logic

* Refactor Docker Compose configuration and Dockerfile copying logic

* Refactor Docker Compose configuration and remove commented environment variables

* Refactor Docker Compose configuration and add backend language choice

* Refactor Docker Compose configuration and update i18n imports

* Refactor Docker Compose configuration and update i18n imports

* Refactor Docker Compose configuration and update i18n imports

* Refactor Docker Compose configuration and update i18n imports

* Refactor Docker Compose configuration and Dockerfile copying logic

* Refactor Docker Compose configuration and Dockerfile copying logic

* Update README

.gitignore

@@ -160,3 +160,4 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+temp

docker/README.md

@@ -1,128 +1,125 @@
-# MindSearch Docker Compose User Guide
+# MSDL (MindSearch Docker Launcher) User Guide
 
 English | [简体中文](README_zh-CN.md)
 
-## 🚀 Quick Start with Docker Compose
+## Introduction
 
-MindSearch now supports quick deployment and startup using Docker Compose. This method simplifies the environment configuration process, allowing you to easily run the entire system.
+MSDL (MindSearch Docker Launcher) is a command-line tool designed to simplify the deployment process of MindSearch. It helps users configure and launch the Docker environment for MindSearch through an interactive interface, reducing the complexity of deployment. MSDL primarily serves as a scaffold for deploying containers and does not involve optimization of MindSearch's core logic.
 
-### Prerequisites
+## Prerequisites
 
-- Docker (Docker Compose V2 is integrated into Docker)
-- NVIDIA GPU and NVIDIA Container Toolkit (required for NVIDIA GPU support)
+- Python 3.7 or higher
+- Docker (Docker Compose included; most newer Docker versions have it integrated)
+- Git (for cloning the repository)
+- Stable internet connection
+- Sufficient disk space (required space varies depending on the selected deployment option)
 
-Note: Newer versions of Docker have integrated Docker Compose V2, so you can use the `docker compose` command directly without a separate installation of docker-compose.
+## Installation Steps
 
-### Usage Instructions
-
-All commands should be executed in the `mindsearch/docker` directory.
-
-#### First-time Startup
-
-```bash
-docker compose up --build -d
-```
-
-#### Daily Use
-
-Start services:
-
-```bash
-docker compose up -d
-```
-
-View running services:
-
-```bash
-docker ps
-```
-
-Stop services:
+1. Clone the MindSearch repository:
+   ```bash
+   git clone https://github.com/InternLM/MindSearch.git # If you have already cloned the repository, you can skip this step.
+   cd MindSearch/docker
+   ```
 
-```bash
-docker compose down
-```
+2. Install MSDL:
+   ```bash
+   pip install -e .
+   ```
 
-#### Major Version Updates
+## Usage
 
-Rebuild images after a major update:
+After installation, you can run the MSDL command from any directory:
 
 ```bash
-docker compose build --no-cache
-docker compose up -d
+msdl
 ```
 
-### Configuration Details
-
-1. **Environment Variables**:
-   The system automatically reads the following variables from your environment:
+Follow the interactive prompts for configuration:
+- Choose the language for the Agent (Chinese or English; this only affects the language of prompts).
+- Select the model deployment type (local model or cloud model).
+- Choose the model format:
+  - Currently, only `internlm_silicon` works properly for cloud models.
+  - For local models, only `internlm_server` has passed tests and runs correctly.
+- Enter the necessary API keys (e.g., SILICON_API_KEY).
 
-   - `OPENAI_API_KEY`: Your OpenAI API key
-   - `OPENAI_API_BASE`: OpenAI API base URL (default: https://api.openai.com/v1)
-   - `LANG`: Language setting ('en' or 'cn')
-   - `MODEL_FORMAT`: Model format ('gpt4' or 'internlm_server')
+MSDL will automatically perform the following actions:
+- Copy and configure the necessary Dockerfile and docker-compose.yaml files.
+- Build Docker images.
+- Launch Docker containers.
 
-   Example setup:
+## Deployment Options Comparison
 
-   Using local internlm2.5-7b-chat model:
+### Cloud Model Deployment (Recommended)
 
-   ```bash
-   export LANG=cn
-   export MODEL_FORMAT=internlm_server
-   docker compose up -d
-   ```
+**Advantages**:
+- Lightweight deployment with minimal disk usage (frontend around 510MB, backend around 839MB).
+- No need for high-performance hardware.
+- Easy to deploy and maintain.
+- You can freely use the `internlm/internlm2_5-7b-chat` model via SiliconCloud.
+- High concurrency, fast inference speed.
 
-   Using OpenAI's API:
+**Instructions**:
+- Select the "Cloud Model" option.
+- Choose "internlm_silicon" as the model format.
+- Enter the SiliconCloud API Key (register at https://cloud.siliconflow.cn/ to obtain it).
 
-   ```bash
-   export OPENAI_API_KEY=your_api_key_here
-   export LANG=en
-   export MODEL_FORMAT=gpt4
-   docker compose up -d
-   ```
+**Important Notes**:
+- The `internlm/internlm2_5-7b-chat` model is freely accessible on SiliconCloud.
+- MindSearch has no financial relationship with SiliconCloud; this service is recommended solely because it provides valuable resources to the open-source community.
 
-   Using SiliconFlow's cloud LLM service:
+### Local Model Deployment
 
-   ```bash
-   export SILICON_API_KEY=your_api_key_here
-   export LANG=en
-   export MODEL_FORMAT=internlm_silicon
-   docker compose up -d
-   ```
+**Features**:
+- Uses the `openmmlab/lmdeploy` image.
+- Based on the PyTorch environment.
+- Requires significant disk space (backend container 15GB+, model 15GB+, totaling 30GB+).
+- Requires a powerful GPU (12GB or more of VRAM recommended).
 
-2. **Model Cache**:
-   The container maps the `/root/.cache:/root/.cache` path to store model files.
+**Instructions**:
+- Select the "Local Model" option.
+- Choose "internlm_server" as the model format.
 
-3. **GPU Support**:
-   The default configuration uses NVIDIA GPUs. For other GPU types, please refer to the comments in docker-compose.yaml.
+**Relevant Links**:
+- lmdeploy image: https://hub.docker.com/r/openmmlab/lmdeploy/tags
+- InternLM2.5 project: https://huggingface.co/internlm/internlm2_5-7b-chat
 
-4. **Service Access**:
-   In the Docker Compose environment, the frontend container can directly access the backend service via `http://backend:8002`.
+## Notes
 
-5. **Backend Server Address Configuration**:
-   Currently, the method for changing the backend server address is temporary. We use a sed command in the Dockerfile to modify the vite.config.ts file to replace the server proxy address. This method is effective in the development environment but not suitable for production.
+- Currently, only the `internlm_silicon` format works properly for cloud models, and only the `internlm_server` format has passed tests for local models.
+- The language selection only affects the language of the Agent's prompts and does not change the language of the React frontend.
+- The first run might take a long time to download necessary model files and Docker images.
+- When using cloud models, ensure a stable network connection.
 
-### Important Notes
+## Troubleshooting
 
-- The first run may take some time to download necessary model files, depending on your chosen model and network conditions.
-- Ensure you have sufficient disk space to store model files and Docker images.
-- If you encounter permission issues, you may need to use sudo to run Docker commands.
+1. Ensure the Docker service is running.
+2. Check if there is sufficient disk space.
+3. Ensure all necessary environment variables are set correctly.
+4. Check if the network connection is stable.
+5. Verify the validity of API keys (e.g., for cloud models).
 
-### Cross-Origin Access Note
+If problems persist, check the Issues section in the MindSearch GitHub repository or submit a new issue.
 
-In the current version, we temporarily solve the cross-origin access issue by using Vite's development mode in the frontend Docker container:
+## Privacy and Security
 
-1. The frontend Dockerfile uses the `npm start` command to start the Vite development server.
-2. In the `vite.config.ts` file, we configure proxy settings to forward requests for the `/solve` path to the backend service.
+MSDL is a locally executed tool and does not transmit any API keys or sensitive information. All configuration information is stored in the `msdl/temp/.env` file, used only to simplify the deployment process.
 
-Please note:
+## Updating MSDL
 
-- This method is effective in the development environment but not suitable for production use.
-- We plan to implement a more robust cross-origin solution suitable for production environments in future versions.
-- If you plan to deploy this project in a production environment, you may need to consider other cross-origin handling methods, such as configuring backend CORS policies or using a reverse proxy server.
+To update MSDL to the latest version, follow these steps:
 
-### Conclusion
+1. Navigate to the MindSearch directory.
+2. Pull the latest code:
+   ```bash
+   git pull origin main
+   ```
+3. Reinstall MSDL:
+   ```bash
+   cd docker
+   pip install -e .
+   ```
 
-We appreciate your understanding and patience. MindSearch is still in its early stages, and we are working hard to improve various aspects of the system. Your feedback is very important to us as it helps us continuously refine the project. If you encounter any issues or have any suggestions during use, please feel free to provide feedback.
+## Conclusion
 
-By using Docker Compose, you can quickly deploy MindSearch without worrying about complex environment configurations. This method is particularly suitable for rapid testing and development environment deployment. If you encounter any problems during deployment, please refer to our troubleshooting guide or seek community support.
+If you have any questions or suggestions, feel free to submit an issue on GitHub or contact us directly. Thank you for using MindSearch and MSDL!

docker/README_zh-CN.md

@@ -1,128 +1,125 @@
-# MindSearch Docker Compose 使用指南
+# MSDL (MindSearch Docker Launcher) 使用指南
 
 [English](README.md) | 简体中文
 
-## 🚀 使用 Docker Compose 快速启动
+## 简介
 
-MindSearch 支持使用 Docker Compose 进行快速部署和启动，简化了环境配置过程，让您能轻松运行整个系统。
+MSDL (MindSearch Docker Launcher) 是一个专为简化 MindSearch 部署过程而设计的命令行工具。它通过交互式界面帮助用户轻松配置和启动 MindSearch 的 Docker 环境，降低了部署的复杂性。MSDL 主要作为部署容器的脚手架，不涉及 MindSearch 核心逻辑的优化。
 
-### 前提条件
+## 环境要求
 
-- Docker（已集成 Docker Compose V2）
-- NVIDIA GPU 和 NVIDIA Container Toolkit（如需 NVIDIA GPU 支持）
+- Python 3.7 或更高版本
+- Docker (需包含 Docker Compose，新版本的 Docker 通常已集成)
+- Git (用于克隆仓库)
+- 稳定的网络连接
+- 充足的磁盘空间（根据选择的部署方案，所需空间有所不同）
 
-注意：较新版本的 Docker 已整合 Docker Compose V2，可直接使用 `docker compose` 命令。
+## 安装步骤
 
-### 使用说明
-
-所有命令都应在 `mindsearch/docker` 目录下执行。
-
-#### 首次启动
-
-```bash
-docker compose up --build -d
-```
-
-#### 日常使用
-
-启动服务：
-
-```bash
-docker compose up -d
-```
-
-查看运行中的服务：
-
-```bash
-docker ps
-```
-
-停止服务：
+1. 克隆 MindSearch 仓库:
+   ```bash
+   git clone https://github.com/InternLM/MindSearch.git # 已经克隆过的，可以忽略执行此步骤
+   cd MindSearch/docker
+   ```
 
-```bash
-docker compose down
-```
+2. 安装 MSDL:
+   ```bash
+   pip install -e .
+   ```
 
-#### 大版本更新
+## 使用方法
 
-更新后重新构建镜像：
+安装完成后，您可以在任意目录下运行 MSDL 命令：
 
 ```bash
-docker compose build --no-cache
-docker compose up -d
+msdl
 ```
 
-### 配置说明
-
-1. **环境变量设置**：
-   系统自动读取以下环境变量：
+按照交互式提示进行配置:
+- 选择 Agent 使用的语言（中文或英文，仅影响 Agent 的提示词语言）
+- 选择模型部署类型（本地模型或云端模型）
+- 选择模型格式
+  - 云端模型目前只有 internlm_silicon 能够正常运行
+  - 本地模型目前只有 internlm_server 通过测试，能正常运行
+- 输入必要的 API 密钥（如 SILICON_API_KEY）
 
-   - `OPENAI_API_KEY`：OpenAI API 密钥
-   - `OPENAI_API_BASE`：OpenAI API 基础 URL（默认：https://api.openai.com/v1）
-   - `LANG`：语言设置（'en' 或 'cn'）
-   - `MODEL_FORMAT`：模型格式（'gpt4' 或 'internlm_server'）
+MSDL 将自动执行以下操作:
+- 复制并配置必要的 Dockerfile 和 docker-compose.yaml 文件
+- 构建 Docker 镜像
+- 启动 Docker 容器
 
-   设置示例：
+## 部署方案比较
 
-   使用本地的 internlm2.5-7b-chat 模型:
+### 云端模型部署（推荐）
 
-   ```bash
-   export LANG=cn
-   export MODEL_FORMAT=internlm_server
-   docker compose up -d
-   ```
+**优势**:
+- 轻量级部署，磁盘占用小（前端约 510MB，后端约 839MB）
+- 无需高性能硬件
+- 部署和维护简单
+- 使用 SiliconCloud 可免费调用 internlm/internlm2_5-7b-chat 模型
+- 高并发量，推理速度快
 
-   使用 OpenAI 的 LLM 服务:
+**使用说明**:
+- 选择"云端模型"选项
+- 选择 "internlm_silicon" 作为模型格式
+- 输入 SiliconCloud API Key（需在 https://cloud.siliconflow.cn/ 注册获取）
 
-   ```bash
-   export OPENAI_API_KEY=your_api_key_here
-   export LANG=cn
-   export MODEL_FORMAT=gpt4
-   docker compose up -d
-   ```
+**重要说明**:
+- internlm/internlm2_5-7b-chat 模型在 SiliconCloud 上可以免费调用，但 API Key 仍需妥善保管好。
+- MindSearch 项目与 SiliconCloud 并无利益关系，只是使用它能更好地体验 MindSearch 的效果，感谢 SiliconCloud 为开源社区所做的贡献。
 
-   使用 SiliconFlow 云端 LLM 服务：
+### 本地模型部署
 
-   ```bash
-   export SILICON_API_KEY=your_api_key_here
-   export LANG=cn
-   export MODEL_FORMAT=internlm_silicon
-   docker compose up -d
-   ```
+**特点**:
+- 使用 openmmlab/lmdeploy 镜像
+- 基于 PyTorch 环境
+- 需要大量磁盘空间（后端容器 15GB+，模型 15GB+，总计 30GB 以上）
+- 需要强大的 GPU（建议 12GB 或以上显存）
 
-2. **模型缓存**：
-   容器映射 `/root/.cache:/root/.cache` 路径存储模型文件。
+**使用说明**:
+- 选择"本地模型"选项
+- 选择 "internlm_server" 作为模型格式
 
-3. **GPU 支持**：
-   默认配置使用 NVIDIA GPU。其他 GPU 类型请参考 docker-compose.yaml 中的注释。
+**相关链接**:
+- lmdeploy 镜像: https://hub.docker.com/r/openmmlab/lmdeploy/tags
+- InternLM2.5 项目: https://huggingface.co/internlm/internlm2_5-7b-chat
 
-4. **服务访问**：
-   在 Docker Compose 环境中，前端容器可以通过 `http://backend:8002` 直接访问后端服务。
+## 注意事项
 
-5. **后端服务器地址配置**：
-   目前，更改后端服务器地址的方法是临时的。我们在 Dockerfile 中使用 sed 命令来修改 vite.config.ts 文件，以替换服务器代理地址。这种方法在开发环境中有效，但不适合生产环境。
+- 云端模型目前只有 internlm_silicon 格式能够正常运行，本地模型只有 internlm_server 格式通过测试能正常运行。
+- 选择语言只会影响 Agent 的提示词语言，不会改变 React 前端的界面语言。
+- 首次运行可能需要较长时间来下载必要的模型文件和 Docker 镜像。
+- 使用云端模型时，请确保网络连接稳定。
 
-### 注意事项
+## 故障排除
 
-- 首次运行可能需要时间下载模型文件。
-- 确保有足够磁盘空间存储模型和 Docker 镜像。
-- 如遇权限问题，可能需要使用 sudo 运行 Docker 命令。
+1. 确保 Docker 服务正在运行。
+2. 检查是否有足够的磁盘空间。
+3. 确保所有必要的环境变量已正确设置。
+4. 检查网络连接是否正常。
+5. 验证 API Key 是否有效（如使用云端模型）。
 
-### 跨域访问说明
+如果问题持续，请查看 MindSearch 的 GitHub 仓库中的 Issues 部分，或提交新的 Issue。
 
-当前版本通过 Vite 开发模式临时解决跨域问题：
+## 隐私和安全
 
-1. 前端 Dockerfile 使用 `npm start` 启动 Vite 开发服务器。
-2. `vite.config.ts` 配置代理，将 `/solve` 路径请求代理到后端。
+MSDL 是纯本地执行的工具，不会上报任何 API Key 或其他敏感信息。所有配置信息存储在 `msdl/temp/.env` 文件中，仅用于简化部署过程。
 
-注意：
+## 更新 MSDL
 
-- 此方法适用于开发环境，不适合生产环境。
-- 未来版本将实现更适合生产环境的跨域解决方案。
-- 生产环境部署可能需要考虑其他跨域处理方法。
+要更新 MSDL 到最新版本，请执行以下步骤:
 
-### 结语
+1. 进入 MindSearch 目录
+2. 拉取最新的代码:
+   ```bash
+   git pull origin main
+   ```
+3. 重新安装 MSDL:
+   ```bash
+   cd docker
+   pip install -e .
+   ```
 
-感谢您的支持。MindSearch 正在不断改进，您的反馈对我们至关重要。如有任何问题或建议，请随时与我们联系。
+## 结语
 
-Docker Compose 方法简化了 MindSearch 的部署流程，特别适合快速测试和开发环境。如遇部署问题，请参考故障排除指南或寻求社区支持。
+如有任何问题或建议，欢迎在 GitHub 上提交 Issue 或直接联系我们。感谢您使用 MindSearch 和 MSDL！

docker/msdl/__main__.py

@@ -0,0 +1,198 @@
+# msdl/__main__.py
+import signal
+import sys
+from pathlib import Path
+
+from InquirerPy import inquirer
+from msdl.config import (
+    BACKEND_DOCKERFILE_DIR,
+    CLOUD_LLM_DOCKERFILE,
+    FRONTEND_DOCKERFILE_DIR,
+    LOCAL_LLM_DOCKERFILE,
+    PACKAGE_DIR,
+    PROJECT_ROOT,
+    REACT_DOCKERFILE,
+    TEMP_DIR,
+    TEMPLATE_FILES,
+)
+from msdl.docker_manager import (
+    check_docker_install,
+    run_docker_compose,
+    stop_and_remove_containers,
+    update_docker_compose_paths,
+)
+from msdl.i18n import setup_i18n, t
+from msdl.utils import (
+    clean_api_key,
+    copy_templates_to_temp,
+    get_existing_api_key,
+    get_model_formats,
+    modify_docker_compose,
+    save_api_key_to_env,
+    validate_api_key,
+)
+
+
+def signal_handler(signum, frame):
+    print(t("TERMINATION_SIGNAL"))
+    stop_and_remove_containers()
+    sys.exit(0)
+
+
+def copy_backend_dockerfile(choice):
+    source_file = Path(BACKEND_DOCKERFILE_DIR) / choice
+    dest_file = "backend.dockerfile"
+    source_path = PACKAGE_DIR / "templates" / source_file
+    dest_path = TEMP_DIR / dest_file
+
+    if not source_path.exists():
+        raise FileNotFoundError(t("FILE_NOT_FOUND", file=source_file))
+
+    dest_path.parent.mkdir(parents=True, exist_ok=True)
+    dest_path.write_text(source_path.read_text())
+    print(
+        t(
+            "BACKEND_DOCKERFILE_COPIED",
+            source_path=str(source_path),
+            dest_path=str(dest_path),
+        )
+    )
+
+
+def copy_frontend_dockerfile():
+    source_file = Path(FRONTEND_DOCKERFILE_DIR) / REACT_DOCKERFILE
+    dest_file = "frontend.dockerfile"
+    source_path = PACKAGE_DIR / "templates" / source_file
+    dest_path = TEMP_DIR / dest_file
+
+    if not source_path.exists():
+        raise FileNotFoundError(t("FILE_NOT_FOUND", file=source_file))
+
+    dest_path.parent.mkdir(parents=True, exist_ok=True)
+    dest_path.write_text(source_path.read_text())
+    print(
+        t(
+            "FRONTEND_DOCKERFILE_COPIED",
+            source_path=str(source_path),
+            dest_path=str(dest_path),
+        )
+    )
+
+
+def get_user_choices():
+    backend_language_choices = [
+        {"name": t("CHINESE"), "value": "cn"},
+        {"name": t("ENGLISH"), "value": "en"},
+    ]
+
+    model_deployment_type = [
+        {"name": t("CLOUD_MODEL"), "value": CLOUD_LLM_DOCKERFILE},
+        {"name": t("LOCAL_MODEL"), "value": LOCAL_LLM_DOCKERFILE},
+    ]
+
+    backend_language = inquirer.select(
+        message=t("BACKEND_LANGUAGE_CHOICE"),
+        choices=backend_language_choices,
+    ).execute()
+
+    model = inquirer.select(
+        message=t("MODEL_DEPLOYMENT_TYPE"),
+        choices=model_deployment_type,
+    ).execute()
+
+    model_formats = get_model_formats(model)
+    model_format = inquirer.select(
+        message=t("MODEL_FORMAT_CHOICE"),
+        choices=[{"name": format, "value": format} for format in model_formats],
+    ).execute()
+
+    # If the model is cloud_llm, ask for the API key
+    if model == CLOUD_LLM_DOCKERFILE:
+        env_var_name = {
+            "internlm_silicon": "SILICON_API_KEY",
+            "gpt4": "OPENAI_API_KEY",
+            "qwen": "QWEN_API_KEY",
+        }.get(model_format)
+
+        existing_api_key = get_existing_api_key(env_var_name)
+
+        if existing_api_key:
+            use_existing = inquirer.confirm(
+                message=t("CONFIRM_USE_EXISTING_API_KEY", ENV_VAR_NAME=env_var_name),
+                default=True,
+            ).execute()
+
+            if use_existing:
+                return backend_language, model, model_format
+            else:
+                print(
+                    t("CONFIRM_OVERWRITE_EXISTING_API_KEY", ENV_VAR_NAME=env_var_name)
+                )
+        else:
+            print(t("PLEASE_INPUT_NEW_API_KEY", ENV_VAR_NAME=env_var_name))
+
+        while True:
+            api_key = inquirer.secret(
+                message=t(
+                    "PLEASE_INPUT_NEW_API_KEY_FROM_ZERO", ENV_VAR_NAME=env_var_name
+                )
+            ).execute()
+            cleaned_api_key = clean_api_key(api_key)
+
+            if validate_api_key(cleaned_api_key, env_var_name, t):
+                save_api_key_to_env(model_format, cleaned_api_key, t)
+                break
+            else:
+                print(t("INVALID_API_KEY_FORMAT"))
+                retry = inquirer.confirm(
+                    message=t("RETRY_API_KEY_INPUT"), default=True
+                ).execute()
+                if not retry:
+                    print(t("API_KEY_INPUT_CANCELLED"))
+                    sys.exit(1)
+
+    return backend_language, model, model_format
+
+
+def main():
+    # Set the display language of the msdl launcher (based on the system language)
+    setup_i18n()
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    try:
+        check_docker_install()
+
+        # Get user choices
+        backend_language, model_choice, model_format = get_user_choices()
+
+        # Copy backend Dockerfile to temp directory
+        copy_backend_dockerfile(model_choice)
+
+        # Copy frontend Dockerfile to temp directory
+        copy_frontend_dockerfile()
+
+        # Copy templates to temp directory
+        copy_templates_to_temp(TEMPLATE_FILES)
+
+        # Modify docker-compose.yaml
+        modify_docker_compose(model_choice, backend_language, model_format)
+
+        update_docker_compose_paths()
+        stop_and_remove_containers()
+        run_docker_compose()
+
+        print(t("DOCKER_LAUNCHER_COMPLETE"))
+    except KeyboardInterrupt:
+        print(t("KEYBOARD_INTERRUPT"))
+        stop_and_remove_containers()
+        sys.exit(0)
+    except Exception as e:
+        print(t("UNEXPECTED_ERROR", error=str(e)))
+        stop_and_remove_containers()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

docker/msdl/config.py

@@ -0,0 +1,34 @@
+# msdl/config.py
+
+from pathlib import Path
+
+# Get the directory where the script is located
+PACKAGE_DIR = Path(__file__).resolve().parent
+
+# Get the root directory of the MindSearch project
+PROJECT_ROOT = PACKAGE_DIR.parent.parent
+
+# Get the temp directory path, which is actually the working directory for executing the docker compose up command
+TEMP_DIR = PACKAGE_DIR / "temp"
+
+# Configuration file name list
+TEMPLATE_FILES = ["docker-compose.yaml"]
+
+# Backend Dockerfile directory
+BACKEND_DOCKERFILE_DIR = "backend"
+
+# Backend Dockerfile name
+CLOUD_LLM_DOCKERFILE = "cloud_llm.dockerfile"
+LOCAL_LLM_DOCKERFILE = "local_llm.dockerfile"
+
+# Frontend Dockerfile directory
+FRONTEND_DOCKERFILE_DIR = "frontend"
+
+# Frontend Dockerfile name
+REACT_DOCKERFILE = "react.dockerfile"
+
+# i18n translations directory
+TRANSLATIONS_DIR = PACKAGE_DIR / "translations"
+
+# Get the path of the .env file
+ENV_FILE_PATH = TEMP_DIR / ".env"

docker/msdl/docker_manager.py

@@ -0,0 +1,135 @@
+# msdl/docker_manager.py
+
+import os
+import subprocess
+import sys
+from functools import lru_cache
+
+import yaml
+from msdl.config import PROJECT_ROOT, TEMP_DIR
+from msdl.i18n import t
+
+
+@lru_cache(maxsize=1)
+def get_docker_command():
+    try:
+        subprocess.run(
+            ["docker", "compose", "version"], check=True, capture_output=True
+        )
+        return ["docker", "compose"]
+    except subprocess.CalledProcessError:
+        try:
+            subprocess.run(
+                ["docker-compose", "--version"], check=True, capture_output=True
+            )
+            return ["docker-compose"]
+        except subprocess.CalledProcessError:
+            print(t("DOCKER_COMPOSE_NOT_FOUND"))
+            sys.exit(1)
+
+
+@lru_cache(maxsize=1)
+def check_docker_install():
+    try:
+        subprocess.run(["docker", "--version"], check=True, capture_output=True)
+        docker_compose_cmd = get_docker_command()
+        subprocess.run(
+            docker_compose_cmd + ["version"], check=True, capture_output=True
+        )
+        print(t("DOCKER_INSTALLED"))
+        return True
+    except subprocess.CalledProcessError as e:
+        print(t("DOCKER_INSTALL_ERROR", error=str(e)))
+        return False
+    except FileNotFoundError:
+        print(t("DOCKER_NOT_FOUND"))
+        return False
+
+
+def stop_and_remove_containers():
+    docker_compose_cmd = get_docker_command()
+    try:
+        subprocess.run(
+            docker_compose_cmd
+            + [
+                "-f",
+                os.path.join(TEMP_DIR, "docker-compose.yaml"),
+                "down",
+                "-v",
+            ],
+            check=True,
+        )
+        print(t("CONTAINERS_STOPPED"))
+    except subprocess.CalledProcessError as e:
+        print(t("CONTAINER_STOP_ERROR", error=str(e)))
+
+
+def run_docker_compose():
+    docker_compose_cmd = get_docker_command()
+    try:
+        print(t("BUILDING_IMAGES"))
+        subprocess.run(
+            docker_compose_cmd
+            + [
+                "-f",
+                os.path.join(TEMP_DIR, "docker-compose.yaml"),
+                "--env-file",
+                os.path.join(TEMP_DIR, ".env"),
+                "build",
+            ],
+            check=True,
+        )
+        print(t("IMAGES_BUILT"))
+        print(t("STARTING_CONTAINERS"))
+        subprocess.run(
+            docker_compose_cmd
+            + [
+                "-f",
+                os.path.join(TEMP_DIR, "docker-compose.yaml"),
+                "--env-file",
+                os.path.join(TEMP_DIR, ".env"),
+                "up",
+                "-d",
+            ],
+            check=True,
+        )
+        print(t("CONTAINERS_STARTED"))
+    except subprocess.CalledProcessError as e:
+        print(t("DOCKER_ERROR", error=str(e)))
+        print(t("DOCKER_OUTPUT"))
+        print(e.output.decode() if e.output else "No output")
+        stop_and_remove_containers()
+        sys.exit(1)
+
+
+def update_docker_compose_paths():
+    docker_compose_path = os.path.join(TEMP_DIR, "docker-compose.yaml")
+    with open(docker_compose_path, "r") as file:
+        compose_data = yaml.safe_load(file)
+    for service in compose_data["services"].values():
+        if "build" in service:
+            if "context" in service["build"]:
+                if service["build"]["context"] == "..":
+                    service["build"]["context"] = PROJECT_ROOT
+                else:
+                    service["build"]["context"] = os.path.join(
+                        PROJECT_ROOT, service["build"]["context"]
+                    )
+            if "dockerfile" in service["build"]:
+                dockerfile_name = os.path.basename(service["build"]["dockerfile"])
+                service["build"]["dockerfile"] = os.path.join(TEMP_DIR, dockerfile_name)
+    with open(docker_compose_path, "w") as file:
+        yaml.dump(compose_data, file)
+    print(t("PATHS_UPDATED"))
+
+
+def main():
+    if check_docker_install():
+        update_docker_compose_paths()
+        run_docker_compose()
+    else:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

docker/msdl/i18n.py

@@ -0,0 +1,38 @@
+# msdl/translations/i18n_setup.py
+
+import os
+import i18n
+import locale
+from msdl.config import TRANSLATIONS_DIR, ENV_FILE_PATH
+
+
+def get_env_variable(var_name, default=None):
+    if os.path.exists(ENV_FILE_PATH):
+        with open(ENV_FILE_PATH, "r") as env_file:
+            for line in env_file:
+                if line.startswith(f"{var_name}="):
+                    return line.strip().split("=", 1)[1]
+    return os.getenv(var_name, default)
+
+
+def get_system_language():
+    try:
+        return locale.getlocale()[0].split("_")[0]
+    except:
+        return "en"
+
+
+def setup_i18n():
+    i18n.load_path.append(TRANSLATIONS_DIR)
+    i18n.set("filename_format", "{locale}.{format}")
+    i18n.set("file_format", "yaml")
+
+    env_language = get_env_variable("LAUNCHER_INTERACTION_LANGUAGE")
+    if env_language:
+        i18n.set("locale", env_language)
+    else:
+        i18n.set("locale", get_system_language())
+
+
+def t(key, **kwargs):
+    return i18n.t(key, **kwargs)

docker/msdl/templates/backend/cloud_llm.dockerfile

@@ -0,0 +1,26 @@
+# Use Python 3.11.9 as the base image
+FROM python:3.11.9-slim
+
+# Set the working directory
+WORKDIR /root
+
+# Install Git
+RUN apt-get update && apt-get install -y git && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Install specified dependency packages
+# Note: lmdeploy dependency is already included in the base image, no need to reinstall
+RUN pip install --no-cache-dir git+https://github.com/InternLM/lagent.git
+
+RUN pip install --no-cache-dir \
+    duckduckgo_search==5.3.1b1 \
+    einops \
+    fastapi \
+    janus \
+    pyvis \
+    sse-starlette \
+    termcolor \
+    uvicorn \
+    griffe==0.48.0
+
+# Copy the mindsearch folder to the /root directory of the container
+COPY mindsearch /root/mindsearch

docker/{docker-compose.yaml → msdl/templates/docker-compose.yaml}

@@ -2,8 +2,8 @@ services:
   backend:
     container_name: mindsearch-backend
     build:
-      context: ..
-      dockerfile: docker/backend.dockerfile
+      context: .
+      dockerfile: backend.dockerfile
     image: mindsearch/backend:latest
     restart: unless-stopped
     # Uncomment the following line to force using local build
@@ -12,9 +12,10 @@ services:
       - "8002:8002"
     environment:
       - PYTHONUNBUFFERED=1
-      - OPENAI_API_KEY=${OPENAI_API_KEY:-}
+      # - OPENAI_API_KEY=${OPENAI_API_KEY:-}
       - OPENAI_API_BASE=${OPENAI_API_BASE:-https://api.openai.com/v1}
-      - SILICON_API_KEY=${SILICON_API_KEY:-}
+      # - QWEN_API_KEY=${QWEN_API_KEY:-}
+      # - SILICON_API_KEY=${SILICON_API_KEY:-}
     command: python -m mindsearch.app --lang ${LANG:-cn} --model_format ${MODEL_FORMAT:-internlm_server}
     volumes:
       - /root/.cache:/root/.cache
@@ -49,8 +50,8 @@ services:
   frontend:
     container_name: mindsearch-frontend
     build:
-      context: ..
-      dockerfile: docker/frontend.dockerfile
+      context: .
+      dockerfile: frontend.dockerfile
     image: mindsearch/frontend:latest
     restart: unless-stopped
     # Uncomment the following line to force using local build

docker/msdl/translations/en.yaml

@@ -0,0 +1,50 @@
+en:
+  SCRIPT_DIR: "Script directory: %{dir}"
+  PROJECT_ROOT: "Project root directory: %{dir}"
+  TEMP_DIR: "Temporary directory: %{dir}"
+  DOCKER_LAUNCHER_START: "Starting Docker launcher process"
+  DOCKER_LAUNCHER_COMPLETE: "Docker launcher process completed"
+  DIR_CREATED: "Directory created: %{dir}"
+  FILE_COPIED: "Copied %{file} to the temp directory"
+  FILE_NOT_FOUND: "Error: %{file} not found in the templates directory"
+  CONTAINERS_STOPPED: "Existing containers and volumes stopped and removed"
+  CONTAINER_STOP_ERROR: "Error stopping and removing containers (this may be normal if there were no running containers): %{error}"
+  BUILDING_IMAGES: "Starting to build Docker images..."
+  IMAGES_BUILT: "Docker images built successfully"
+  STARTING_CONTAINERS: "Starting Docker containers..."
+  CONTAINERS_STARTED: "Docker containers started successfully"
+  DOCKER_ERROR: "Error while building or starting Docker containers: %{error}"
+  DOCKER_OUTPUT: "Docker command output:"
+  DOCKER_INSTALLED: "Docker and Docker Compose installed correctly"
+  DOCKER_INSTALL_ERROR: "Error: Docker or Docker Compose may not be installed correctly: %{error}"
+  DOCKER_NOT_FOUND: "Error: Docker or Docker Compose command not found. Please ensure they are correctly installed and added to the PATH."
+  DOCKER_COMPOSE_NOT_FOUND: "Error: Docker Compose command not found. Please ensure it is correctly installed and added to the PATH."
+  PATHS_UPDATED: "Paths updated in docker-compose.yaml"
+  COMPOSE_FILE_CONTENT: "docker-compose.yaml file content:"
+  COMPOSE_FILE_NOT_FOUND: "Error: %{file} file not found"
+  COMPOSE_FILE_READ_ERROR: "Error reading docker-compose.yaml file: %{error}"
+  TERMINATION_SIGNAL: "Termination signal caught. Exiting gracefully..."
+  KEYBOARD_INTERRUPT: "Keyboard interrupt caught. Exiting gracefully..."
+  UNEXPECTED_ERROR: "An unexpected error occurred: %{error}"
+  BACKEND_LANGUAGE_CHOICE: "Select backend language (default is cn):"
+  CHINESE: "中文(cn)"
+  ENGLISH: "English(en)"
+  MODEL_DEPLOYMENT_TYPE: "Select model deployment type:"
+  CLOUD_MODEL: "Cloud model"
+  LOCAL_MODEL: "Local model"
+  MODEL_FORMAT_CHOICE: "Select model format:"
+  CONFIRM_USE_EXISTING_API_KEY: "Do you want to use the existing %{ENV_VAR_NAME} API key?"
+  CONFIRM_OVERWRITE_EXISTING_API_KEY: "Do you want to overwrite the existing %{ENV_VAR_NAME} API key?"
+  PLEASE_INPUT_NEW_API_KEY: "Please enter a new %{ENV_VAR_NAME} API key:"
+  PLEASE_INPUT_NEW_API_KEY_FROM_ZERO: "Please enter a new %{ENV_VAR_NAME} API key:"
+  INVALID_API_KEY_FORMAT: "Invalid API key format"
+  RETRY_API_KEY_INPUT: "Retry API key input"
+  API_KEY_INPUT_CANCELLED: "API key input cancelled"
+  UNKNOWN_API_KEY_TYPE: "Unknown API key type: %{KEY_TYPE}"
+  UNKNOWN_MODEL_FORMAT: "Unknown model format: %{MODEL_FORMAT}"
+  INVALID_API_KEY: "Invalid API key: %{KEY_TYPE}"
+  API_KEY_SAVED: "API key for %{ENV_VAR_NAME} saved"
+  UNKNOWN_DOCKERFILE: "Unknown Dockerfile: %{dockerfile}"
+  UNKNOWN_MODEL_TYPE: "Unknown model type: %{model_type}"
+  BACKEND_DOCKERFILE_COPIED: "Backend Dockerfile copied from %{source_path} to %{dest_path}"
+  FRONTEND_DOCKERFILE_COPIED: "Frontend Dockerfile copied from %{source_path} to %{dest_path}"

docker/msdl/translations/zh_CN.yaml

@@ -0,0 +1,50 @@
+zh_CN:
+  SCRIPT_DIR: "脚本目录：%{dir}"
+  PROJECT_ROOT: "项目根目录：%{dir}"
+  TEMP_DIR: "临时目录：%{dir}"
+  DOCKER_LAUNCHER_START: "开始 Docker 启动器流程"
+  DOCKER_LAUNCHER_COMPLETE: "Docker 启动器流程完成"
+  DIR_CREATED: "创建目录：%{dir}"
+  FILE_COPIED: "已复制 %{file} 到 temp 目录"
+  FILE_NOT_FOUND: "错误：%{file} 在 templates 目录中不存在"
+  CONTAINERS_STOPPED: "已停止并删除现有容器和卷"
+  CONTAINER_STOP_ERROR: "停止和删除容器时出错（这可能是正常的，如果没有正在运行的容器）：%{error}"
+  BUILDING_IMAGES: "开始构建Docker镜像..."
+  IMAGES_BUILT: "Docker镜像构建成功"
+  STARTING_CONTAINERS: "开始启动Docker容器..."
+  CONTAINERS_STARTED: "Docker 容器已成功启动"
+  DOCKER_ERROR: "构建或启动 Docker 容器时出错：%{error}"
+  DOCKER_OUTPUT: "Docker 命令输出："
+  DOCKER_INSTALLED: "Docker 和 Docker Compose 安装正确"
+  DOCKER_INSTALL_ERROR: "错误：Docker 或 Docker Compose 可能没有正确安装：%{error}"
+  DOCKER_NOT_FOUND: "错误：Docker 或 Docker Compose 命令未找到。请确保它们已正确安装并添加到PATH中。"
+  DOCKER_COMPOSE_NOT_FOUND: "错误：Docker Compose 命令未找到。请确保它已正确安装并添加到PATH中。"
+  PATHS_UPDATED: "已更新 docker-compose.yaml 中的路径"
+  COMPOSE_FILE_CONTENT: "docker-compose.yaml 文件内容："
+  COMPOSE_FILE_NOT_FOUND: "错误：%{file} 文件不存在"
+  COMPOSE_FILE_READ_ERROR: "读取 docker-compose.yaml 文件时出错：%{error}"
+  TERMINATION_SIGNAL: "捕获到终止信号。正在优雅地退出..."
+  KEYBOARD_INTERRUPT: "捕获到键盘中断。正在优雅地退出..."
+  UNEXPECTED_ERROR: "发生未预期的错误：%{error}"
+  BACKEND_LANGUAGE_CHOICE: "选择后端语言（默认为 cn）："
+  CHINESE: "中文(cn)"
+  ENGLISH: "English(en)"
+  MODEL_DEPLOYMENT_TYPE: "选择模型部署类型："
+  CLOUD_MODEL: "云端模型"
+  LOCAL_MODEL: "本地模型"
+  MODEL_FORMAT_CHOICE: "选择模型格式："
+  CONFIRM_USE_EXISTING_API_KEY: "是否使用现有的 %{ENV_VAR_NAME} API 密钥？"
+  CONFIRM_OVERWRITE_EXISTING_API_KEY: "是否覆盖现有的 %{ENV_VAR_NAME} API 密钥？"
+  PLEASE_INPUT_NEW_API_KEY: "请输入新的 %{ENV_VAR_NAME} API 密钥："
+  PLEASE_INPUT_NEW_API_KEY_FROM_ZERO: "请输入新的 %{ENV_VAR_NAME} API 密钥："
+  INVALID_API_KEY_FORMAT: "无效的 API 密钥格式"
+  RETRY_API_KEY_INPUT: "重试 API 密钥输入"
+  API_KEY_INPUT_CANCELLED: "API 密钥输入已取消"
+  UNKNOWN_API_KEY_TYPE: "未知的 API 密钥类型：%{KEY_TYPE}"
+  UNKNOWN_MODEL_FORMAT: "未知的模型格式：%{MODEL_FORMAT}"
+  INVALID_API_KEY: "无效的 API 密钥：%{KEY_TYPE}"
+  API_KEY_SAVED: "%{ENV_VAR_NAME} 的 API 密钥已保存"
+  UNKNOWN_DOCKERFILE: "未知的 Dockerfile：%{dockerfile}"
+  UNKNOWN_MODEL_TYPE: "未知的模型类型：%{model_type}"
+  BACKEND_DOCKERFILE_COPIED: "后端 Dockerfile 已经从 %{source_path} 复制为 %{dest_path}"
+  FRONTEND_DOCKERFILE_COPIED: "前端 Dockerfile 已经从 %{source_path} 复制为 %{dest_path}"

docker/msdl/utils.py

@@ -0,0 +1,172 @@
+# msdl/utils.py
+
+import os
+import re
+import shutil
+import sys
+import yaml
+from functools import lru_cache
+from pathlib import Path
+from msdl.config import (
+    CLOUD_LLM_DOCKERFILE,
+    LOCAL_LLM_DOCKERFILE,
+    PACKAGE_DIR,
+    TEMP_DIR,
+    ENV_FILE_PATH,
+)
+from msdl.i18n import t
+
+
+@lru_cache(maxsize=None)
+def get_env_variable(var_name, default=None):
+    if ENV_FILE_PATH.exists():
+        with ENV_FILE_PATH.open("r") as env_file:
+            for line in env_file:
+                if line.startswith(f"{var_name}="):
+                    return line.strip().split("=", 1)[1]
+    return os.getenv(var_name, default)
+
+
+@lru_cache(maxsize=None)
+def get_existing_api_key(env_var_name):
+    env_vars = read_env_file()
+    return env_vars.get(env_var_name)
+
+
+@lru_cache(maxsize=None)
+def read_env_file():
+    env_vars = {}
+    if ENV_FILE_PATH.exists():
+        with ENV_FILE_PATH.open("r") as env_file:
+            for line in env_file:
+                if "=" in line and not line.strip().startswith("#"):
+                    key, value = line.strip().split("=", 1)
+                    env_vars[key] = value.strip('"').strip("'")
+    return env_vars
+
+
+def clean_api_key(api_key):
+    cleaned_key = api_key.strip()
+    cleaned_key = re.sub(r"\s+", "", cleaned_key)
+    return cleaned_key
+
+
+@lru_cache(maxsize=None)
+def validate_api_key(api_key, key_type, t):
+    basic_pattern = r"^sk-[A-Za-z0-9]+$"
+
+    validation_rules = {
+        "SILICON_API_KEY": basic_pattern,
+        "OPENAI_API_KEY": basic_pattern,
+        "QWEN_API_KEY": basic_pattern,
+    }
+
+    if key_type not in validation_rules:
+        raise ValueError(t("UNKNOWN_API_KEY_TYPE", KEY_TYPE=key_type))
+
+    pattern = validation_rules[key_type]
+    return re.match(pattern, api_key) is not None
+
+
+def ensure_directory(path):
+    path = Path(path)
+    if not path.exists():
+        path.mkdir(parents=True, exist_ok=True)
+        print(t("DIR_CREATED", dir=path))
+
+
+def copy_templates_to_temp(template_files):
+    template_dir = PACKAGE_DIR / "templates"
+
+    ensure_directory(TEMP_DIR)
+
+    for filename in template_files:
+        src = template_dir / filename
+        dst = TEMP_DIR / filename
+        if src.exists():
+            shutil.copy2(src, dst)
+            print(t("FILE_COPIED", file=filename))
+        else:
+            print(t("FILE_NOT_FOUND", file=filename))
+            sys.exit(1)
+
+
+def save_api_key_to_env(model_format, api_key, t):
+    env_var_name = {
+        "internlm_silicon": "SILICON_API_KEY",
+        "gpt4": "OPENAI_API_KEY",
+        "qwen": "QWEN_API_KEY",
+    }.get(model_format)
+
+    if not env_var_name:
+        raise ValueError(t("UNKNOWN_MODEL_FORMAT", MODEL_FORMAT=model_format))
+
+    if not validate_api_key(api_key, env_var_name, t):
+        raise ValueError(t("INVALID_API_KEY", KEY_TYPE=env_var_name))
+
+    env_vars = read_env_file()
+    env_vars[env_var_name] = api_key
+
+    with ENV_FILE_PATH.open("w") as env_file:
+        for key, value in env_vars.items():
+            env_file.write(f"{key}={value}\n")
+
+    print(t("API_KEY_SAVED", ENV_VAR_NAME=env_var_name))
+
+
+def modify_docker_compose(selected_dockerfile, backend_language, model_format):
+    docker_compose_path = TEMP_DIR / "docker-compose.yaml"
+
+    with docker_compose_path.open("r") as file:
+        compose_data = yaml.safe_load(file)
+
+    backend_service = compose_data["services"]["backend"]
+
+    if "env_file" not in backend_service:
+        backend_service["env_file"] = [".env"]
+    elif ".env" not in backend_service["env_file"]:
+        backend_service["env_file"].append(".env")
+
+    command = f"python -m mindsearch.app --lang {backend_language} --model_format {model_format}"
+    if selected_dockerfile == CLOUD_LLM_DOCKERFILE:
+        if "deploy" in backend_service:
+            del backend_service["deploy"]
+        backend_service["command"] = command
+    elif selected_dockerfile == LOCAL_LLM_DOCKERFILE:
+        if "deploy" not in backend_service:
+            backend_service["deploy"] = {
+                "resources": {
+                    "reservations": {
+                        "devices": [
+                            {"driver": "nvidia", "count": 1, "capabilities": ["gpu"]}
+                        ]
+                    }
+                }
+            }
+        backend_service["command"] = command
+    else:
+        raise ValueError(t("UNKNOWN_DOCKERFILE", dockerfile=selected_dockerfile))
+
+    with docker_compose_path.open("w") as file:
+        yaml.dump(compose_data, file)
+
+    print(
+        t(
+            "docker_compose_updated",
+            mode=(
+                t("CLOUD")
+                if selected_dockerfile == CLOUD_LLM_DOCKERFILE
+                else t("LOCAL")
+            ),
+            format=model_format,
+        )
+    )
+
+
+def get_model_formats(model_type):
+    if model_type == CLOUD_LLM_DOCKERFILE:
+        return ["internlm_silicon", "qwen", "gpt4"]
+    elif model_type == LOCAL_LLM_DOCKERFILE:
+        return ["internlm_server", "internlm_client", "internlm_hf"]
+    else:
+        raise ValueError(t("UNKNOWN_MODEL_TYPE", model_type=model_type))

docker/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="msdl",
+    version="0.1.0",
+    description="MindSearch Docker Launcher",
+    packages=find_packages(),
+    python_requires=">=3.7",
+    install_requires=[
+        "pyyaml>=6.0",
+        "python-i18n>=0.3.9",
+        "inquirerpy>=0.3.4",
+    ],
+    entry_points={
+        "console_scripts": [
+            "msdl=msdl.__main__:main",
+        ],
+    },
+    include_package_data=True,
+    package_data={
+        "msdl": ["translations/*.yaml", "templates/*"],
+    },
+)