FastAPI+Docker构建向量计算微服务：Embedding与Rerank解耦实践

1. 为什么这个服务架构值得你花30分钟认真读完

我去年在做三个不同客户的大模型应用项目时，反复踩同一个坑：每次上线新项目，都要重新加载一遍 embedding 模型——768维的 multilingual-e5-large-instruct 占内存2.1GB，rerank 模型 bge-reranker-v2-m3 又要1.4GB，光模型加载就卡住接口3.8秒。更糟的是，三个项目用的其实是同一套向量计算逻辑，但各自维护三份 FastAPI 路由、三套 Dockerfile、三套健康检查脚本，运维同事半夜被 OOM 告警叫醒成了常态。

这根本不是技术问题，是架构冗余。Embedding 和 Rerank 本质是无状态的纯计算函数：输入文本，输出向量或排序分数，不依赖用户会话、不修改数据库、不产生副作用。它们天然适合抽离成独立服务——就像当年我们把短信发送、邮件推送从主业务里拆出来做成微服务一样。FastAPI 提供了极轻量的异步 HTTP 接口能力，Docker 则解决了模型环境固化和资源隔离问题。两者组合，不是“又一个部署教程”，而是把向量计算从“每个项目重复造轮子”变成“调用本地 HTTP 接口”的范式切换。

核心关键词 fastapi、docker、embedding、rerank 在这里不是堆砌标签，而是精准对应三层能力：fastapi 是接口层的最小可行载体（比 Flask 启动快47%，异步支持原生）；docker 是模型运行时的确定性封装（避免“在我机器上能跑”的玄学）；embedding 和 rerank 是服务暴露的两个正交能力域（前者解决“文本→向量”，后者解决“查询+候选→重排序”）。如果你正在用 LangChain、LlamaIndex 或自研 RAG 流程，这个服务能直接替换掉你代码里那些from sentence_transformers import SentenceTransformer和from FlagEmbedding import FlagReranker的导入语句——不用改一行业务逻辑，只改一个 URL。

它适合四类人：刚跑通第一个 RAG demo 的新手（省去模型下载/环境配置的3小时折腾）；带多个项目的团队技术负责人（统一管理模型版本、监控指标、限流策略）；需要快速验证不同 embedding 模型效果的算法同学（热替换模型文件，无需重建镜像）；以及被客户要求“必须支持私有化部署”的交付工程师（单机 Docker Compose 一键拉起，连 Kubernetes 都不用碰）。

2. 整体架构设计与关键决策逻辑

2.1 为什么放弃“模型加载到主应用”的传统做法

先说结论：模型加载成本远高于网络调用开销。很多人直觉认为“本地调用肯定比 HTTP 快”，但在 embedding 场景下这是个典型误区。我们实测过三种方案（数据基于 Intel Xeon Silver 4314 + 64GB RAM + NVMe SSD）：

关键洞察在于：模型加载是一次性阻塞操作，而 embedding 计算是短时 CPU 密集型任务。当你的 API QPS 达到 50+ 时，独立服务的吞吐量反而更高——因为主应用不再被模型加载锁死，且 Docker 容器可单独分配 CPU 核心（如--cpus=2.5），避免与其他业务争抢资源。

提示：不要用curl http://localhost:8000/embedding测试延迟！真实场景中，你的 LangChain Chain 会通过httpx.AsyncClient复用连接池，实测 100 并发下 P95 延迟稳定在 160ms 内，比进程内调用还低 15ms（得益于 FastAPI 异步 IO 优化）。

2.2 为什么选 FastAPI 而非 Flask/Fastify/Express

FastAPI 在此场景有三个不可替代优势：

1. 原生异步支持：embedding 计算虽是 CPU 密集型，但模型推理前的数据预处理（tokenize）、推理后的向量归一化、HTTP 响应序列化全是 IO 密集型。FastAPI 的async def路由能让这些步骤并发执行。我们对比过 Flask 的threading.Thread方案：当批量请求 100 个文本时，FastAPI 平均耗时 1.2s，Flask 线程池方案为 2.7s（线程创建/销毁开销过大）。

2. 自动文档与类型校验：/embedding接口接收{"texts": ["hello", "world"], "model": "e5"}这样的 JSON，FastAPI 自动生成 OpenAPI 文档，前端调试时直接点“Try it out”；更重要的是，它会在请求到达业务逻辑前完成字段校验（如texts必须是 list[str]，长度不能超 100），避免无效请求触发模型加载。这点在生产环境救过我们两次——某次前端传入空字符串数组，Flask 服务直接 OOM，而 FastAPI 返回422 Unprocessable Entity。

3. 依赖注入系统：模型实例作为Depends()注入路由，天然实现单例模式。你不需要写if model is None: load_model()这种判断，框架保证整个生命周期只初始化一次。代码简洁度提升50%，且避免多线程下的竞态条件。

注意：别被“FastAPI 适合高并发”误导。它的并发优势体现在 IO 密集场景，对纯 CPU 计算（如大模型推理）仍需配合loop.run_in_executor将计算移出事件循环。我们在rerank路由中正是这样做的。

2.3 为什么 Docker 是唯一合理选择

有人问：“用 systemd 管理 Python 进程不行吗？”——可以，但会陷入运维泥潭。Docker 解决了三个本质问题：

• 环境确定性：multilingual-e5-large-instruct依赖transformers==4.41.0和torch==2.3.0+cu121，而你的主应用可能用torch==2.1.0。Docker 镜像将 Python 版本、CUDA 驱动、模型权重、依赖库全部打包，启动即运行，杜绝“版本冲突导致向量结果不一致”的灾难。

• 资源硬隔离：通过docker run --memory=4g --cpus=2.5严格限制服务资源。当 rerank 模型因长文本触发显存暴涨时，容器会被 OOM Killer 杀死并自动重启，不会拖垮宿主机上其他服务。我们曾在线上环境观察到：未加内存限制的 Flask 进程吃光 64GB 内存，导致 MySQL 被迫 swap，整个系统雪崩。

• 部署一致性：开发机（Mac M2）、测试服务器（Ubuntu 22.04）、客户私有云（CentOS 7）用同一份Dockerfile构建镜像。我们甚至用docker buildx交叉编译 ARM64 镜像，让客户在国产飞腾服务器上也能跑通——这种跨平台能力，是任何 shell 脚本部署方案无法企及的。

3. 核心细节解析与实操要点

3.1 模型选型与性能权衡：不是越大越好

标题里提到的deepseek embedding和bce-等模型，在实际选型中需根据场景取舍。我们压测了 5 款主流开源模型（测试集：MS MARCO dev set，1000 个 query+doc 对）：

关键结论：

• 不要盲目追求 SOTA 指标：bge-reranker-v2-m3的 R@100 比bge-reranker-base高 2.3%，但推理慢 40%。在实时搜索场景，用户感知不到 0.023 的召回率提升，却会因响应超时流失。
• 中文场景慎用 multilingual 模型：multilingual-e5在中文上表现不错，但jina-embeddings-v2-base-zh对中文成语、缩略语理解更准（如“双碳目标”、“专精特新”），且支持更长上下文。
• rerank 模型必须与 embedding 模型匹配：用e5生成的向量，必须用bge-reranker类模型重排序。混用text2vec+bge-reranker会导致相关性分数失真——因为两者的向量空间分布不同。

实操心得：在config.yaml中预留model_mapping字段，明确指定哪些 embedding 模型对应哪些 rerank 模型。例如：

model_mapping: e5: bge-reranker-v2-m3 jina: bge-reranker-base

这样当用户调用/rerank?model=e5时，服务自动加载对应的 rerank 模型，避免人工配错。

3.2 FastAPI 服务代码的关键陷阱与规避

下面这段看似简单的 FastAPI 代码，藏着三个致命坑：

# ❌ 危险写法 @app.post("/embedding") def get_embedding(texts: List[str]): embeddings = model.encode(texts) # 坑1：未限制长度 return {"embeddings": embeddings.tolist()}

坑1：未做输入长度校验
model.encode()遇到超长文本（如 10MB 日志文件）会触发 OOM。正确做法是：

# ✅ 安全写法 from pydantic import BaseModel, Field class EmbeddingRequest(BaseModel): texts: List[str] = Field(..., max_length=100) # 限制最多100个文本 model: str = "e5" # 新增长度限制 max_length: int = Field(512, ge=128, le=8192) # token 最大长度 @app.post("/embedding") def get_embedding(request: EmbeddingRequest): # 截断超长文本（保留首尾，中间用[TRUNCATED]代替） truncated_texts = [] for text in request.texts: tokens = tokenizer.encode(text) if len(tokens) > request.max_length: half = request.max_length // 2 truncated = tokenizer.decode(tokens[:half]) + "[TRUNCATED]" + tokenizer.decode(tokens[-half:]) truncated_texts.append(truncated) else: truncated_texts.append(text) embeddings = model.encode(truncated_texts) return {"embeddings": embeddings.tolist()}

坑2：未处理 CUDA 显存泄漏
PyTorch 模型在多次 encode 后显存不释放。解决方案是强制清空缓存：

import torch @app.post("/embedding") def get_embedding(request: EmbeddingRequest): try: embeddings = model.encode(request.texts, convert_to_numpy=True) return {"embeddings": embeddings.tolist()} finally: # 关键！每次请求后清空 CUDA 缓存 if torch.cuda.is_available(): torch.cuda.empty_cache()

坑3：未设置超时与重试
客户端网络抖动时，FastAPI 默认等待 60 秒才返回 504。应在uvicorn启动参数中显式控制：

# 启动命令 uvicorn main:app --host 0.0.0.0 --port 8000 \ --timeout-keep-alive 5 \ # HTTP keep-alive 超时 --timeout-graceful-shutdown 30 \ # 优雅关闭超时 --limit-concurrency 100 \ # 限制并发连接数 --workers 2 # 启动2个 worker 进程

3.3 Docker 部署的 5 个硬性规范

Dockerfile 不是写完就能用，必须遵循以下生产级规范：

规范1：基础镜像必须指定小版本号

# ❌ 危险：alpine:latest 可能升级到不兼容的 glibc FROM python:3.11-slim-bookworm # ✅ 正确：锁定具体版本，确保构建可重现 FROM python:3.11.9-slim-bookworm

规范2：模型权重必须外部挂载，禁止 COPY 到镜像

# ❌ 错误：模型文件随镜像分发，体积膨胀且无法热更新 COPY models/ /app/models/ # ✅ 正确：通过 docker run -v 挂载，镜像体积<200MB # Dockerfile 中只声明挂载点 VOLUME ["/app/models"]

规范3：必须启用非 root 用户运行

# 创建非 root 用户 RUN groupadd -g 1001 -f appuser && useradd -s /bin/bash -u 1001 -m appuser USER appuser # 所有后续指令以 appuser 身份执行

规范4：健康检查必须验证模型加载状态

# 健康检查脚本 healthcheck.sh #!/bin/sh # 检查模型是否加载成功（通过访问 /health 端点） curl -f http://localhost:8000/health || exit 1 # 额外检查：确认模型文件存在 test -f /app/models/e5/pytorch_model.bin || exit 1

HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ CMD ["/app/healthcheck.sh"]

规范5：日志必须输出到 stdout，禁止写文件

# ✅ 正确：所有日志走 print() 或 logging.info() import logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) @app.get("/health") def health_check(): logger.info("Health check passed") # 输出到 stdout return {"status": "ok"}

这样docker logs -f embedding-service才能实时看到日志，便于 ELK 或 Loki 采集。

4. 实操过程与核心环节实现

4.1 从零开始搭建服务的完整步骤

步骤1：准备模型文件（离线环境友好）

不要依赖pip install下载模型，这在客户内网会失败。我们采用“模型预下载+校验”方案：

# 1. 在有网环境下载模型（以 e5 为例） mkdir -p models/e5 cd models/e5 # 使用 huggingface-hub 工具下载（比 git clone 更可靠） pip install huggingface-hub huggingface-cli download --resume-download \ intfloat/multilingual-e5-large-instruct \ --local-dir . \ --local-dir-use-symlinks False # 2. 生成 SHA256 校验码 sha256sum pytorch_model.bin config.json tokenizer.json > checksums.txt # 3. 将 models/ 目录打包，交付给客户 tar -czf models.tar.gz models/

客户收到models.tar.gz后，解压到任意路径（如/opt/embedding-models），启动时挂载即可：

docker run -d \ --name embedding-service \ -v /opt/embedding-models:/app/models \ -p 8000:8000 \ -e MODEL_DIR=/app/models \ embedding-service:1.0

步骤2：编写核心 FastAPI 应用（main.py）

import os import torch from fastapi import FastAPI, HTTPException, Depends from pydantic import BaseModel, Field from typing import List, Optional, Dict, Any from transformers import AutoTokenizer, AutoModel from FlagEmbedding import FlagReranker import logging # 配置日志 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) app = FastAPI(title="Embedding & Rerank Service", version="1.0") # 全局模型缓存（单例） _models = {} def get_model(model_name: str): """按需加载模型，避免启动时全量加载""" if model_name not in _models: logger.info(f"Loading model: {model_name}") if model_name == "e5": tokenizer = AutoTokenizer.from_pretrained("/app/models/e5") model = AutoModel.from_pretrained("/app/models/e5").to("cuda" if torch.cuda.is_available() else "cpu") _models[model_name] = {"tokenizer": tokenizer, "model": model, "type": "embedding"} elif model_name == "bge-reranker-v2-m3": model = FlagReranker("/app/models/bge-reranker-v2-m3", use_fp16=True) _models[model_name] = {"model": model, "type": "rerank"} else: raise HTTPException(status_code=400, detail=f"Unknown model: {model_name}") return _models[model_name] # 请求模型定义 class EmbeddingRequest(BaseModel): texts: List[str] = Field(..., min_items=1, max_items=100) model: str = "e5" normalize: bool = True class RerankRequest(BaseModel): query: str documents: List[str] = Field(..., min_items=1, max_items=100) model: str = "bge-reranker-v2-m3" # 健康检查 @app.get("/health") def health_check(): return {"status": "ok", "models_loaded": list(_models.keys())} # Embedding 接口 @app.post("/embedding") def get_embedding(request: EmbeddingRequest): try: model_data = get_model(request.model) if model_data["type"] != "embedding": raise HTTPException(status_code=400, detail="Model type mismatch") # 文本截断（防 OOM） texts = [] for text in request.texts: tokens = model_data["tokenizer"].encode(text, truncation=True, max_length=512) texts.append(model_data["tokenizer"].decode(tokens)) # 执行编码 with torch.no_grad(): inputs = model_data["tokenizer"](texts, padding=True, truncation=True, return_tensors="pt") inputs = {k: v.to(model_data["model"].device) for k, v in inputs.items()} outputs = model_data["model"](**inputs) embeddings = outputs.last_hidden_state.mean(dim=1) if request.normalize: embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1) return {"embeddings": embeddings.cpu().numpy().tolist()} except Exception as e: logger.error(f"Embedding error: {str(e)}") raise HTTPException(status_code=500, detail=str(e)) finally: if torch.cuda.is_available(): torch.cuda.empty_cache() # Rerank 接口 @app.post("/rerank") def rerank_documents(request: RerankRequest): try: model_data = get_model(request.model) if model_data["type"] != "rerank": raise HTTPException(status_code=400, detail="Model type mismatch") # FlagReranker 的 rerank 方法 scores = model_data["model"].compute_score([[request.query, doc] for doc in request.documents]) # 返回排序后的文档和分数 results = [{"document": doc, "score": float(score)} for doc, score in zip(request.documents, scores)] results.sort(key=lambda x: x["score"], reverse=True) return {"results": results} except Exception as e: logger.error(f"Rerank error: {str(e)}") raise HTTPException(status_code=500, detail=str(e)) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000, workers=2)

步骤3：构建 Docker 镜像（Dockerfile）

# 使用多阶段构建，减小最终镜像体积 FROM python:3.11.9-slim-bookworm AS builder # 安装构建依赖 RUN apt-get update && apt-get install -y --no-install-recommends \ gcc \ && rm -rf /var/lib/apt/lists/* # 复制 requirements.txt 并安装依赖 COPY requirements.txt . RUN pip install --no-cache-dir --upgrade pip RUN pip install --no-cache-dir -r requirements.txt # 生产镜像 FROM python:3.11.9-slim-bookworm # 创建非 root 用户 RUN groupadd -g 1001 -f appuser && useradd -s /bin/bash -u 1001 -m appuser USER appuser # 复制依赖（从 builder 阶段） COPY --from=builder /usr/local/lib/python3.11/site-packages /home/appuser/.local/lib/python3.11/site-packages COPY --from=builder /usr/local/bin /home/appuser/.local/bin # 设置工作目录 WORKDIR /app COPY --chown=appuser:appuser . . # 声明挂载点 VOLUME ["/app/models"] # 暴露端口 EXPOSE 8000 # 健康检查 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \ CMD curl -f http://localhost:8000/health || exit 1 # 启动命令 CMD ["uvicorn", "main:app", "--host", "0.0.0.0:8000", "--port", "8000", "--workers", "2"]

requirements.txt内容：

fastapi==0.111.0 uvicorn[standard]==0.29.0 transformers==4.41.0 torch==2.3.0+cu121 sentence-transformers==3.0.1 FlagEmbedding==1.3.0 pydantic==2.7.4 huggingface-hub==0.23.4

步骤4：一键部署脚本（deploy.sh）

#!/bin/bash # 通用部署脚本，适配 Ubuntu/CentOS/macOS set -e MODEL_DIR="/opt/embedding-models" SERVICE_NAME="embedding-service" IMAGE_NAME="embedding-service:1.0" echo "🔍 检测 Docker 环境..." if ! command -v docker &> /dev/null; then echo "❌ Docker 未安装，请先安装 Docker" exit 1 fi echo "📦 构建镜像..." docker build -t $IMAGE_NAME . echo "📁 创建模型目录..." sudo mkdir -p $MODEL_DIR echo "⬇️ 下载默认模型（可跳过，使用自有模型）..." if [ ! -d "$MODEL_DIR/e5" ]; then echo "正在下载 multilingual-e5-large-instruct..." # 此处可替换为客户提供的模型包解压命令 # tar -xzf models.tar.gz -C $MODEL_DIR echo "⚠️ 请手动将模型放入 $MODEL_DIR/e5 和 $MODEL_DIR/bge-reranker-v2-m3" fi echo "🚀 启动服务..." docker run -d \ --name $SERVICE_NAME \ --restart=unless-stopped \ --memory=4g \ --cpus=2.5 \ --network=host \ -v $MODEL_DIR:/app/models \ -e MODEL_DIR=/app/models \ -p 8000:8000 \ $IMAGE_NAME echo "✅ 部署完成！访问 http://localhost:8000/docs 查看 API 文档" echo "💡 测试 embedding：curl -X POST http://localhost:8000/embedding -H 'Content-Type: application/json' -d '{\"texts\":[\"hello world\"]}'"

4.2 性能调优的 3 个关键参数

参数1：Uvicorn 的--workers数量

这不是简单设为 CPU 核心数。我们通过压测发现：

• --workers=1：单进程，CPU 利用率峰值 85%，QPS 42
• --workers=2：双进程，CPU 利用率均衡，QPS 89（提升112%）
• --workers=3：三进程，进程间竞争显存，QPS 降为 76

结论：worker 数 = GPU 数 × 2（单卡情况下设为 2）。因为 PyTorch 模型加载在 GPU 上，多进程能更好利用 GPU 并行能力。

参数2：PyTorch 的torch.set_num_threads

在 CPU 模式下（无 GPU），必须显式设置线程数：

# 在 main.py 开头添加 import torch torch.set_num_threads(2) # 限制为2线程，避免争抢

否则默认使用全部 CPU 核心，导致系统负载飙升，其他服务响应变慢。

参数3：Docker 的--oom-kill-disable=false

这是默认值，但必须显式确认：

docker run --oom-kill-disable=false ... # 确保 OOM 时容器被杀死而非僵死

配合--memory=4g，当模型推理意外吃光内存时，容器会立即重启，保障服务可用性。

5. 常见问题与排查技巧实录

5.1 模型加载失败：500 Internal Server Error

现象：docker logs embedding-service显示OSError: Can't load tokenizer...
根因分析：模型目录权限问题。Docker 以appuser（UID 1001）运行，但挂载的模型目录属主是root（UID 0），导致无读取权限。
排查命令：

# 检查挂载目录权限 ls -l /opt/embedding-models/e5/ # 输出：drwxr-xr-x 3 root root 4096 Jun 10 10:00 e5 # appuser 无法读取 root 目录

解决方案：

# 方案1（推荐）：修改模型目录属组 sudo chgrp 1001 /opt/embedding-models/e5 sudo chmod g+rX /opt/embedding-models/e5 # 方案2：启动时指定用户 docker run -u 1001:1001 -v /opt/embedding-models:/app/models ...

5.2 接口响应慢：P95 延迟 > 500ms

现象：单次请求很快，但批量请求（100 文本）延迟飙升
根因分析：model.encode()默认 batch_size=32，但我们的文本长度差异大（有的10字，有的2000字），导致 GPU 显存碎片化，实际 batch 处理效率低下。
解决方案：动态调整 batch_size

# 在 get_embedding 函数中 batch_size = 8 if any(len(t) > 500 for t in request.texts) else 32 embeddings = model.encode(request.texts, batch_size=batch_size)

实测效果：长文本场景延迟从 820ms 降至 310ms。

5.3 Rerank 结果为空：{"results": []}

现象：/rerank接口返回空数组，无错误日志
根因分析：FlagReranker.compute_score()对输入格式极其敏感——必须是[[query, doc1], [query, doc2]]的二维列表，若传入[query, doc1, doc2]会静默失败。
排查技巧：在 rerank 路由中添加调试日志：

logger.debug(f"Rerank input shape: {len([[request.query, doc] for doc in request.documents])}")

修复：确保构造输入格式正确（已在上文代码中体现）。

5.4 Docker 启动失败：failed to start daemon

现象：docker run报错Cannot connect to the Docker daemon
根因分析：Docker Engine 未启动，常见于 Linux 系统。
解决方案：

# Ubuntu/Debian sudo systemctl start docker sudo systemctl enable docker # CentOS/RHEL sudo systemctl start docker sudo systemctl enable docker # macOS（Docker Desktop） open /Applications/Docker.app

5.5 模型版本混乱：不同项目调用结果不一致

现象：A 项目调用/embedding?model=e5得到向量 A，B 项目调用相同接口得到向量 B（数值不同）
根因分析：两个项目挂载了不同版本的e5模型（如 A 用intfloat/multilingual-e5-large-instruct@v1.2，B 用@v1.0），而模型权重更新会影响向量空间。
终极方案：在服务中加入模型指纹校验

# 在 get_model() 中添加 import hashlib def get_model_fingerprint(model_path: str) -> str: # 计算 pytorch_model.bin 的 SHA256 with open(f"{model_path}/pytorch_model.bin", "rb") as f: return hashlib.sha256(f.read()).hexdigest()[:8] # 加载后记录指纹 _models[model_name]["fingerprint"] = get_model_fingerprint(model_path)

然后在/health接口返回指纹，运维可随时核对各环境模型一致性。

6. 运维与扩展建议

6.1 监控指标必须采集的 4 个维度

不要只看 CPU 和内存，Embedding 服务的核心指标是：

我们用 20 行 Python 代码实现了 Prometheus metrics 暴露：

from prometheus_client import Counter, Histogram, Gauge # 定义指标 EMBEDDING_LATENCY = Histogram('embedding_latency_seconds', 'Embedding latency', ['model']) EMBEDDING_ERRORS = Counter('embedding_errors_total', 'Total embedding errors', ['model', 'error_type']) MODEL_LOADED = Gauge('model_loaded', 'Model loaded status', ['model']) @app.middleware("http") async def record_latency(request: Request, call_next): start_time = time.time() try: response = await call_next(request) latency = time.time() - start_time EMBEDDING_LATENCY.labels(model=request.query_params.get("model", "unknown")).observe(latency) return response except Exception as e: EMBEDDING_ERRORS.labels(model=request.query_params.get("model", "unknown"), error_type=type(e).__name__).inc() raise

6.2 如何安全地热更新模型

客户要求“不中断服务更新模型”，标准流程是：

1. 准备新模型：将新版e5放到/opt/embedding-models/e5-v2/
2. 更新软链接：

   cd /opt/embedding-models rm e5 ln -s e5-v2 e5

3. 触发模型重载：调用POST /reload?model=e5（需在代码中实现该 endpoint）

   @app.post("/reload") def reload_model(model_name: str): if model_name in _models: del _models[model_name] return {"status": "reloaded", "model": model_name}

4