浏览器
  → Dify（知识库 / 工作流 / Agent）
      → 对话：New-API（鉴权、额度）→ vLLM qwen3.6-27b → GPU
      → 向量和重排：Xinference（bge-m3、bge-reranker-v2-m3）→ GPU 0

#!/bin/bash
# 已在 10.0.1.47 执行。不要拿它去重建正在跑的 Dify，除非容器已经不在。
# 不启动、不重启 vLLM 和 New-API。
set -eu

ROOT=/usr/cluster/dify
SRC="$ROOT/src"
cd "$ROOT"

if [ ! -d "$SRC/docker" ]; then
  git clone --depth 1 --filter=blob:none --sparse --branch 1.17.1 \
    https://github.com/langgenius/dify.git "$SRC"
  git -C "$SRC" sparse-checkout set docker
fi

cd "$SRC/docker"
cp -n .env.example .env

# 主机 80 端口已被占用，Dify 改到 8088。向量库用 pgvector，不拉 weaviate。
sed -i \
  -e 's/^EXPOSE_NGINX_PORT=.*/EXPOSE_NGINX_PORT=8088/' \
  -e 's/^EXPOSE_NGINX_SSL_PORT=.*/EXPOSE_NGINX_SSL_PORT=18443/' \
  -e 's/^VECTOR_STORE=.*/VECTOR_STORE=pgvector/' \
  -e 's/^CELERY_WORKER_AMOUNT=.*/CELERY_WORKER_AMOUNT=2/' \
  -e 's/^COMPOSE_PROJECT_NAME=.*/COMPOSE_PROJECT_NAME=dify/' \
  .env
grep -q '^NEXT_PUBLIC_ENABLE_AGENT_V2=' .env \
  && sed -i 's/^NEXT_PUBLIC_ENABLE_AGENT_V2=.*/NEXT_PUBLIC_ENABLE_AGENT_V2=true/' .env \
  || echo 'NEXT_PUBLIC_ENABLE_AGENT_V2=true' >> .env

# 官方镜像名。现场是先从 docker.m.daocloud.io 拉取再打回这些标签。
docker compose up -d
docker compose ps

COMPOSE_PROJECT_NAME=dify
VECTOR_STORE=pgvector
DB_TYPE=postgresql
COMPOSE_PROFILES=${VECTOR_STORE:-weaviate},${DB_TYPE:-postgresql},collaboration
EXPOSE_NGINX_PORT=8088
EXPOSE_NGINX_SSL_PORT=18443
CELERY_WORKER_AMOUNT=2
NEXT_PUBLIC_ENABLE_AGENT_V2=true
PLUGIN_DEBUGGING_PORT=5003
NGINX_CLIENT_MAX_BODY_SIZE=100M
SSRF_PROXY_ALLOW_PRIVATE_IPS=172.17.0.0/16,10.0.0.0/8

POST /console/api/login
{"email":"admin@example.com","password":"<Dify-rag-2026 的 Base64>","language":"zh-Hans","remember_me":true}

#!/bin/bash
# 已在 10.0.1.47 执行。向量和重排都在 GPU 0 上。
# 容器如果已经存在，不要再 docker run 一次。
# docker rm 之后重建，需要再装一次 sentence-transformers，并重新加载两个模型。
set -eu

mkdir -p /usr/cluster/dify/xinference

docker run -d \
  --name xinference-bge \
  --restart unless-stopped \
  --gpus all \
  --cpus 4 \
  --memory 12g \
  --memory-swap 12g \
  -p 9997:9997 \
  -e XINFERENCE_HOME=/data \
  -e XINFERENCE_MODEL_SRC=modelscope \
  -v /usr/cluster/dify/xinference:/data \
  xprobe/xinference:latest \
  xinference-local -H 0.0.0.0 --log-level info

docker exec xinference-bge pip install -i https://pypi.tuna.tsinghua.edu.cn/simple sentence-transformers

POST /v1/models?wait_ready=true
{
  "model_name": "bge-m3",
  "model_type": "embedding",
  "n_gpu": 1,
  "download_hub": "modelscope"
}

#!/usr/bin/env python3
"""记录已经完成的模型注册。知识库向量走 Xinference，对话走 New-API 的 dify-gateway。

重复执行会碰到「模型已存在」。看到 Can't add same credential 可以停。
不要再创建第二把名为 dify-gateway 的令牌。
"""
import json
import os
import urllib.request

DIFY = os.environ.get("DIFY", "http://127.0.0.1:8088")
XINFERENCE = "http://172.17.0.1:9997"
NEW_API = "http://172.17.0.1:3000/v1"
GATEWAY_KEY = os.environ["DIFY_GATEWAY_KEY"]


def post(url, body, headers):
    request = urllib.request.Request(url, data=json.dumps(body).encode(), method="POST")
    request.add_header("Content-Type", "application/json")
    for key, value in headers.items():
        request.add_header(key, value)
    with urllib.request.urlopen(request, timeout=60) as resp:
        return resp.status


llm = {
    "model": "qwen3.6-27b",
    "model_type": "llm",
    "credentials": {
        "mode": "chat",
        "context_size": "65536",
        "max_tokens_to_sample": "8192",
        "function_calling_type": "tool_call",
        "stream_function_calling": "supported",
        "display_name": "qwen3.6-27b",
        "endpoint_url": NEW_API,
        "api_key": GATEWAY_KEY,
    },
}
embedding = {
    "model": "bge-m3",
    "model_type": "text-embedding",
    "credentials": {
        "server_url": XINFERENCE,
        "model_uid": "bge-m3",
    },
}

POST /console/api/workspaces/current/model-providers/<provider>/models/credentials
POST /console/api/workspaces/current/default-model

#!/bin/bash
# 已在 10.0.1.47 执行。工具请求经 Squid 访问 http://172.17.0.1:8777。
# 再跑一次只会改这一行环境变量，并重建两个代理容器。
# 不重建 dify-web-1、api、vLLM、New-API。
set -eu

python3 - <<'PY'
from pathlib import Path
path = Path("/usr/cluster/dify/src/docker/.env")
lines = path.read_text(encoding="utf-8").splitlines()
for index, line in enumerate(lines):
    if line.startswith("SSRF_PROXY_ALLOW_PRIVATE_IPS="):
        lines[index] = "SSRF_PROXY_ALLOW_PRIVATE_IPS=172.17.0.0/16,10.0.0.0/8"
        break
else:
    raise SystemExit("找不到 SSRF_PROXY_ALLOW_PRIVATE_IPS")
path.write_text("\n".join(lines) + "\n", encoding="utf-8")
print("SSRF_PROXY_ALLOW_PRIVATE_IPS=172.17.0.0/16,10.0.0.0/8")
PY

cd /usr/cluster/dify/src/docker
docker compose -p dify up -d --force-recreate --no-deps ssrf_proxy agent_ssrf_proxy

#!/usr/bin/env python3
"""作业 1 的模拟服务器状态接口。operationId 对应 Langfuse 里的 getServerStatus。"""
import json
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import parse_qs, urlparse


class Handler(BaseHTTPRequestHandler):
    def do_GET(self):
        parsed = urlparse(self.path)
        if parsed.path == "/health":
            self._send({"status": "ok"})
            return
        if parsed.path == "/server/status":
            name = (parse_qs(parsed.query).get("server_name") or ["unknown"])[0]
            self._send(
                {
                    "server": name,
                    "cpu": "45%",
                    "memory": "62%",
                    "gpu_util": "78%",
                    "gpu_memory": "18.2/24 GB",
                }
            )
            return
        self.send_response(404)
        self.end_headers()

    def _send(self, payload):
        body = json.dumps(payload, ensure_ascii=False).encode()
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def log_message(self, fmt, *args):
        print("%s - %s" % (self.address_string(), fmt % args), flush=True)


if __name__ == "__main__":
    ThreadingHTTPServer(("0.0.0.0", 8777), Handler).serve_forever()

[Unit]
Description=Homework server status API
After=network.target

[Service]
ExecStart=/usr/bin/python3 /usr/cluster/server-status/app.py
WorkingDirectory=/usr/cluster/server-status
Restart=always
RestartSec=2

[Install]
WantedBy=multi-user.target

openapi: 3.0.0
info:
  title: Server Status API
  version: 1.0.0
  description: 模拟查询服务器 CPU、内存、GPU 状态
servers:
  - url: http://172.17.0.1:8777
paths:
  /server/status:
    get:
      operationId: getServerStatus
      summary: 查询服务器状态
      description: 根据服务器名称返回 CPU、内存、GPU 利用率等模拟指标
      parameters:
        - name: server_name
          in: query
          required: true
          description: 服务器名称，例如 gpu-server-01
          schema:
            type: string
      responses:
        "200":
          description: 成功
          content:
            application/json:
              schema:
                type: object
                properties:
                  server:
                    type: string
                  cpu:
                    type: string
                  memory:
                    type: string
                  gpu_util:
                    type: string
                  gpu_memory:
                    type: string

#!/usr/bin/env python3
"""注册 getServerStatus，并挂到「运维巡检 Agent」。

现网已经执行过。再跑时，同名工具和同名 Agent 已存在就只打印编号，不删除、不重建。
在 10.0.1.47 上执行。Windows 上传后先去掉 CR：sed -i 's/\r$//' 本文件。
"""
from __future__ import annotations

import base64
import json
from http.cookiejar import CookieJar
from pathlib import Path
from urllib import request

BASE = "http://127.0.0.1:8088/console/api"
PROVIDER = "server_status"
TOOL_NAME = "getServerStatus"
APP_NAME = "运维巡检 Agent"
AGENT_ID = "01a124c7-9fce-70a8-9efa-41b2a6f5b7e7"
APP_ID = "e4d614f6-de22-4f4c-b58e-caeb0504b121"
PROVIDER_ID = "a69388a5-c02f-4bf1-8c28-1f20ee0687e6"
SCHEMA_PATH = Path(__file__).resolve().parents[1] / "config" / "server-status-openapi.yaml"

SYSTEM_PROMPT = """你是企业内部运维助手。当用户询问某台服务器的状态、CPU、内存、GPU 时，
必须调用工具 getServerStatus（参数 server_name），并根据工具返回结果用中文格式化汇报。

汇报格式示例：
- 服务器：{server}
- CPU：{cpu}
- 内存：{memory}
- GPU 利用率：{gpu_util}
- GPU 显存：{gpu_memory}

不要编造指标；工具失败时如实说明。"""

ADD_BODY = {
    "provider": PROVIDER,
    "credentials": {"auth_type": "none"},
    "schema_type": "openapi",
    "schema": SCHEMA_PATH.read_text(encoding="utf-8"),
    "icon": {"background": "#E8F5E9", "content": "S"},
    "privacy_policy": "",
    "custom_disclaimer": "",
    "labels": [],
}

CREATE_AGENT_BODY = {
    "name": APP_NAME,
    "description": "带 HTTP 工具的运维巡检 Agent，查询服务器状态",
    "icon_type": "emoji",
    "icon": "🖥️",
    "icon_background": "#E8F5E9",
    "role": "ops",
}

TOOL_ENTRY = {
    "enabled": True,
    "provider_type": "api",
    "provider_id": PROVIDER_ID,
    "tool_name": TOOL_NAME,
    "credential_type": "unauthorized",
    "credential_ref": None,
    "runtime_parameters": {},
}


class Dify:
    def __init__(self) -> None:
        self.jar = CookieJar()
        self.opener = request.build_opener(request.HTTPCookieProcessor(self.jar))
        self.csrf = ""

    def login(self) -> None:
        self.call(
            "POST",
            "/login",
            {
                "email": "admin@example.com",
                "password": base64.b64encode(b"Dify-rag-2026").decode(),
                "language": "zh-Hans",
                "remember_me": True,
            },
        )
        for cookie in self.jar:
            if cookie.name == "csrf_token":
                self.csrf = cookie.value
        if not self.csrf:
            raise SystemExit("没有拿到 csrf_token")

    def call(self, method: str, path: str, payload: dict | None = None) -> tuple[int, dict | list]:
        data = None if payload is None else json.dumps(payload).encode()
        req = request.Request(BASE + path, data=data, method=method)
        if payload is not None:
            req.add_header("Content-Type", "application/json")
        if self.csrf:
            req.add_header("X-CSRF-Token", self.csrf)
        with self.opener.open(req, timeout=60) as resp:
            raw = resp.read().decode()
            body = json.loads(raw) if raw else {}
            return resp.status, body


def enable_trace(dify: Dify, app_id: str) -> None:
    env: dict[str, str] = {}
    for line in open("/usr/cluster/observability/langfuse/.env", encoding="utf-8"):
        line = line.strip()
        if line and not line.startswith("#") and "=" in line:
            key, value = line.split("=", 1)
            env[key] = value.strip().strip('"')
    dify.call(
        "POST",
        "/apps/%s/trace-config" % app_id,
        {
            "tracing_provider": "langfuse",
            "tracing_config": {
                "public_key": env["LANGFUSE_INIT_PROJECT_PUBLIC_KEY"],
                "secret_key": env["LANGFUSE_INIT_PROJECT_SECRET_KEY"],
                "host": "http://172.17.0.1:3100",
            },
        },
    )
    dify.call(
        "POST",
        "/apps/%s/trace" % app_id,
        {"enabled": True, "tracing_provider": "langfuse"},
    )
    print("追踪已打开", app_id)


def main() -> None:
    dify = Dify()
    dify.login()
    _status, tools = dify.call("GET", "/workspaces/current/tools/api")
    names = [(item.get("name") or item.get("provider")) for item in tools]
    if PROVIDER in names:
        print("工具已在", PROVIDER, PROVIDER_ID)
    else:
        status, _created = dify.call("POST", "/workspaces/current/tool-provider/api/add", ADD_BODY)
        print("已注册", PROVIDER, status)

    _status, listed = dify.call("GET", "/agent?page=1&limit=50")
    found = None
    for item in listed.get("data") or []:
        if item.get("name") == APP_NAME:
            found = item
            break
    if found:
        print("Agent 已在", found.get("agent_id") or found.get("id"), "app", APP_ID)
        enable_trace(dify, APP_ID)
        return

    status, created = dify.call("POST", "/agent", CREATE_AGENT_BODY)
    agent_id = created.get("agent_id") or created.get("id")
    print("已创建", status, agent_id)
    _status, state = dify.call("GET", "/agent/%s/composer" % agent_id)
    soul = state["agent_soul"]
    soul.setdefault("prompt", {})["system_prompt"] = SYSTEM_PROMPT
    soul.setdefault("tools", {})["dify_tools"] = [TOOL_ENTRY]
    soul.setdefault("tools", {})["cli_tools"] = soul["tools"].get("cli_tools") or []
    model = soul.get("model") if isinstance(soul.get("model"), dict) else {}
    model.update(
        {
            "credential_ref": None,
            "model": "qwen3.6-27b",
            "model_provider": "langgenius/openai_api_compatible/openai_api_compatible",
            "plugin_id": "langgenius/openai_api_compatible",
        }
    )
    soul["model"] = model
    dify.call(
        "PUT",
        "/agent/%s/composer" % agent_id,
        {
            "variant": "agent_app",
            "save_strategy": "save_to_current_version",
            "agent_soul": soul,
            "version_note": "挂上 getServerStatus",
        },
    )
    dify.call("POST", "/agent/%s/publish" % agent_id, {"version_note": "挂上 getServerStatus"})
    print("已发布", agent_id)
    enable_trace(dify, state.get("app_id") or state.get("backing_app_id") or APP_ID)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""给 Dify 的 Langfuse 上报补上工具 Span。

现网的 dify-worker-1 已经打过。容器如果按镜像重建，这段会丢，再在 10.0.1.47 上执行本文件。
不重启 vLLM、New-API、dify-web-1。执行完会重启 dify-worker-1。
"""
from __future__ import annotations

import subprocess
from pathlib import Path

TRACE_PATH = "/app/api/.venv/lib/python3.12/site-packages/dify_trace_langfuse/langfuse_trace.py"
MARKER = "# AGENT_TOOL_SPANS_V2"
ANCHOR = """        self.add_generation(langfuse_generation_data)

    def moderation_trace(self, trace_info: ModerationTraceInfo):
"""
BLOCK = """        try:
            langfuse_generation_data.id = str(message_id)
        except Exception:
            pass

        self.add_generation(langfuse_generation_data)

        # AGENT_TOOL_SPANS_V2
        try:
            from sqlalchemy import select

            from core.db.session_factory import session_factory
            from models.model import MessageAgentThought

            with session_factory.create_session() as session:
                thoughts = session.scalars(
                    select(MessageAgentThought)
                    .where(MessageAgentThought.message_id == str(message_id))
                    .order_by(MessageAgentThought.position.asc())
                ).all()
                logger.info("agent tool spans count=%s message_id=%s", len(thoughts), message_id)
                for at in thoughts:
                    for tn in at.tools:
                        if not tn:
                            continue
                        tool_inp = at.tool_inputs_dict.get(tn)
                        outputs = at.tool_outputs_dict if isinstance(at.tool_outputs_dict, dict) else {}
                        tool_output = outputs.get(tn)
                        if tool_output in (None, "", {}):
                            tool_output = at.observation or None
                        meta = at.tool_meta.get(tn, {}) if isinstance(at.tool_meta, dict) else {}
                        time_cost_f = float(getattr(at, "latency", 0) or 0)
                        if not time_cost_f:
                            try:
                                time_cost_f = float((meta or {}).get("time_cost") or 0)
                            except (TypeError, ValueError):
                                time_cost_f = 0.0
                        if not time_cost_f:
                            time_cost_f = 0.2
                        start_t = at.created_at or trace_info.start_time
                        if start_t is not None and getattr(start_t, "tzinfo", None) is None:
                            start_t = start_t.replace(tzinfo=UTC)
                        end_t = start_t + timedelta(seconds=time_cost_f) if start_t else None
                        err = (meta or {}).get("error")
                        self.add_span(
                            LangfuseSpan(
                                name=tn,
                                input=tool_inp,
                                output=tool_output,
                                trace_id=trace_id,
                                parent_observation_id=str(message_id),
                                start_time=start_t,
                                end_time=end_t,
                                metadata={**metadata, "tool_name": tn, "time_cost": time_cost_f},
                                level=(LevelEnum.DEFAULT if not err else LevelEnum.ERROR),
                                status_message=str(err or ""),
                            )
                        )
        except Exception:
            logger.exception("agent tool spans patch failed")

    def moderation_trace(self, trace_info: ModerationTraceInfo):
"""
ID_OLD = 'id=data.get("id"),'
ID_NEW = 'id=data.get("id") or self._make_event_id(),'


def patch_text(text: str) -> str:
    if MARKER not in text:
        if ANCHOR not in text:
            raise SystemExit("找不到 message_trace 锚点，文件版本可能已变")
        text = text.replace(ANCHOR, BLOCK, 1)
    text = text.replace(ID_OLD, ID_NEW)
    return text


def write_container(container: str, text: str) -> None:
    remote = Path("/tmp/langfuse_trace.py")
    remote.write_text(text, encoding="utf-8")
    subprocess.check_call(["docker", "cp", str(remote), "%s:%s" % (container, TRACE_PATH)])
    check = subprocess.run(
        ["docker", "exec", container, "python", "-m", "py_compile", TRACE_PATH],
        capture_output=True,
        text=True,
    )
    if check.returncode != 0:
        raise SystemExit(check.stderr)
    print(container, "ok")


def main() -> None:
    raw = subprocess.check_output(["docker", "exec", "dify-worker-1", "cat", TRACE_PATH], text=True)
    patched = patch_text(raw)
    write_container("dify-worker-1", patched)
    write_container("dify-api-1", patched)
    subprocess.check_call(["docker", "restart", "dify-worker-1"])
    print("dify-worker-1 已重启")


if __name__ == "__main__":
    main()

#!/bin/bash
# 已执行。重排模型在 GPU 0 上，Dify 默认重排模型是 bge-reranker-v2-m3。
set -eu
echo "先确认 xinference-bge 能看到 GPU，并且内存是 12G"
docker inspect xinference-bge --format 'memory={{.HostConfig.Memory}} gpu={{json .Config.Env}}'
echo "模型加载请求："
cat <<'EOF'
POST http://127.0.0.1:9997/v1/models?wait_ready=true
Authorization: Bearer <Xinference 管理员密钥>
{
  "model_name": "bge-reranker-v2-m3",
  "model_type": "rerank",
  "n_gpu": 1,
  "download_hub": "modelscope"
}
EOF
echo "Dify 里把默认 rerank 设为 langgenius/xinference/xinference 的 bge-reranker-v2-m3。"
echo "新建知识库时，检索设置里打开 Rerank，选这个模型。"

#!/usr/bin/env python3
"""给「阿里云合同条款」接上知识库。现网已经执行过，知识库 id 固定。

重复跑「创建知识库」会再索引一份文档。只在知识库不存在时使用创建请求。
"""
DATASET_ID = "71042108-5f9a-4856-a0db-4359e8e7fa98"
FILE_ID = "c74afc20-f95b-4be1-b548-aad73abb5325"
AGENT_ID = "01a1236c-4cc3-7fb9-bfce-c730a318bdf9"
PROVIDER = "langgenius/xinference/xinference"

init_body = {
    "name": "阿里云合同条款",
    "indexing_technique": "high_quality",
    "doc_form": "text_model",
    "doc_language": "Chinese",
    "embedding_model": "bge-m3",
    "embedding_model_provider": PROVIDER,
    "data_source": {
        "info_list": {
            "data_source_type": "upload_file",
            "file_info_list": {"file_ids": [FILE_ID]},
        }
    },
    "process_rule": {"mode": "automatic"},
    "retrieval_model": {
        "search_method": "hybrid_search",
        "reranking_enable": True,
        "reranking_mode": "reranking_model",
        "reranking_model": {
            "reranking_provider_name": PROVIDER,
            "reranking_model_name": "bge-reranker-v2-m3",
        },
        "top_k": 4,
        "score_threshold_enabled": False,
        "weights": {
            "weight_type": "customized",
            "vector_setting": {
                "vector_weight": 0.7,
                "embedding_provider_name": PROVIDER,
                "embedding_model_name": "bge-m3",
            },
            "keyword_setting": {"keyword_weight": 0.3},
        },
    },
}

knowledge_set = {
    "id": "retrieval-1",
    "name": "Retrieval 1",
    "description": "阿里云框架合同原文及附件",
    "datasets": [{"id": DATASET_ID, "name": "阿里云合同条款"}],
    "query": {"mode": "generated_query"},
    "retrieval": {
        "mode": "multiple",
        "top_k": 4,
        "reranking_mode": "reranking_model",
        "reranking_enable": True,
        "reranking_model": {"provider": PROVIDER, "model": "bge-reranker-v2-m3"},
    },
    "metadata_filtering": {"mode": "disabled"},
}

PUT /console/api/agent/01a1236c-4cc3-7fb9-bfce-c730a318bdf9/composer
{"variant":"agent_app","save_strategy":"save_to_current_version","agent_soul": ...}

POST /console/api/agent/01a1236c-4cc3-7fb9-bfce-c730a318bdf9/publish
{"version_note":"接入合同知识库，开启混合检索、Rerank 和引用"}

#!/usr/bin/env python3
"""打开 Dify 配置页上的「知识检索」。官方镜像把这个开关编译成关闭。

只改 dify-web-1 里的前端包，然后重启这一个容器。
不要重启 dify-api、New-API 或 vLLM。
容器如果被删除重建，镜像里的开关会回到关闭，需要再执行一次。
"""
import subprocess

OLD = 'ENABLE_AGENT_KNOWLEDGE_RETRIEVAL",0,!1'
NEW = 'ENABLE_AGENT_KNOWLEDGE_RETRIEVAL",0,!0'
ROOT = "/app/targets/next/web/.next"

listing = subprocess.check_output(
    ["docker", "exec", "dify-web-1", "grep", "-R", "-F", "-l", "ENABLE_AGENT_KNOWLEDGE_RETRIEVAL", ROOT],
    text=True,
)
changed = 0
for path in [line.strip() for line in listing.splitlines() if line.strip()]:
    local = "/tmp/" + path.strip("/").replace("/", "_")
    subprocess.check_call(["docker", "cp", f"dify-web-1:{path}", local])
    text = open(local, encoding="utf-8", errors="replace").read()
    count = text.count(OLD)
    if count == 0:
        print("skip", path, "already", text.count(NEW))
        continue
    open(local, "w", encoding="utf-8").write(text.replace(OLD, NEW))
    subprocess.check_call(["docker", "cp", local, f"dify-web-1:{path}"])
    print("patched", path, count)
    changed += count

if changed:
    subprocess.check_call(["docker", "restart", "dify-web-1"])
    print("restarted dify-web-1")
else:
    print("flag already enabled")