模型接口上线不能只看一次请求成功

一次请求成功，很容易让人觉得这就是证据。其实不是。

你发出一个 prompt，收到合法的 JSON，然后把它接进每晚运行的任务。

接着，任务在一个你没有配置过的环境里运行。Python 不同，依赖包不同，超时设置也不同。模型没变，你的流水线却照样出了问题。

那么，最初那个 200 OK 究竟证明了什么？对于它周围的系统，几乎什么都没证明。

大多数“模型把我的构建搞坏了”的故事，都发生在这个认知缺口里。下面这五个误区让缺口一直存在，而一个探测脚本可以帮你补上它。

误区 1：“它回答成功过一次，所以能用。”

一次成功，只能证明正常路径存在，不能证明这条路径能稳定复现。

并发、长输入、空输入，各有各的失败方式。每一种都值得单独设置测试用例。

正确的理解：一次回复只是一个样本，不是一份契约。要统计次数，别凭感觉。

误区 2：“免费模型访问和免费服务器是一回事。”

它们是两种独立资源，也会各自独立出问题。

端点能正常响应时，你的机器可能已经没有磁盘空间。你的机器一切正常时，端点也可能拒绝你的请求。如果把两者混在一起排查，你什么也弄不清。

正确的理解：访问能力和计算资源，应该是检测报告里分开的两栏。永远不要把它们合并。

误区 3：“Temperature 0 能让重放检查有意义。”

不能。Temperature 0 会降低随机性，但不保证输出文本逐字节一致。

所以，对模型输出做哈希，是一道不可靠的检查关卡。它会因为与你的 bug 无关的原因亮红灯，然后你就花上一下午，追查一个根本不存在的问题。

正确的理解：对环境做哈希，别对句子做哈希。比较机器状态、依赖包版本和状态码集合。

误区 4：“探测失败，说明服务商不行。”

探测总是在某一道具体关卡失败，而每道关卡都有明确的责任方。

传输失败，问题在端点或你的网络。契约失败，通常是你的 prompt 或解析器有问题。环境失败，问题在你的镜像。把责任都推给服务商，会把这三类问题全部掩盖掉。

正确的理解：一道关卡亮红灯，意味着一项有明确负责人的待办，而不是一个判决。

误区 5：“免费套餐只适合写一次性代码。”

免费资源是验证场，却很不适合承载生产业务。

但它非常适合帮你发现：你以为已经跑通的工作流，其实还没真正成立。在这里发现问题，成本很低；到了生产环境再发现，代价就大了。

正确的理解：用免费访问拿到检测报告，再用报告决定什么时候付费。

交付物：三道关卡，一份检测报告

我只维护一个脚本。它运行三道检查关卡，输出一份 JSON 检测报告。

Gate A——传输。发送 N 次请求，统计状态码。记录实际耗时，只为让性能回退能被看见。

Gate B——契约。发送你真正关心的边界输入，统计输出结构不符合约定的情况。

Gate C——环境重放。为机器生成指纹，绝不为模型文本生成指纹。

完整代码如下。它可以调用任何兼容 OpenAI 的端点。

# probe.py - three-gate pre-flight for any OpenAI-compatible endpoint
import hashlib, json, os, subprocess, sys, time, urllib.error, urllib.request

BASE  = os.environ["PROBE_BASE_URL"].rstrip("/")
KEY   = os.environ["PROBE_API_KEY"]
MODEL = os.environ["PROBE_MODEL"]
N     = int(os.environ.get("PROBE_N", "8"))

EDGE_PROMPTS = [
    "",                                    # empty input
    'Reply with JSON: {"ok": true}',       # contract ask
    "\U0001F642" * 200,                     # unicode weight
    "x " * 4000,                           # long input
]

def call(prompt, timeout=45):
    payload = json.dumps({
        "model": MODEL,
        "messages": [{"role": "user", "content": prompt}],
        "temperature": 0,
    }).encode()
    req = urllib.request.Request(
        BASE + "/chat/completions",
        data=payload,
        headers={"Content-Type": "application/json",
                 "Authorization": "Bearer " + KEY},
    )
    start = time.monotonic()
    try:
        with urllib.request.urlopen(req, timeout=timeout) as resp:
            body = json.loads(resp.read())
            status = resp.status
    except urllib.error.HTTPError as err:
        return {"status": err.code, "seconds": time.monotonic() - start, "text": None}
    except Exception:
        return {"status": 0, "seconds": time.monotonic() - start, "text": None}
    text = body.get("choices", [{}])[0].get("message", {}).get("content")
    return {"status": status, "seconds": time.monotonic() - start, "text": text}

def gate_a():
    """Transport: does it answer at all, under my concurrency?"""
    runs = [call("ping") for _ in range(N)]
    return {
        "requests": N,
        "ok": sum(1 for r in runs if r["status"] == 200),
        "statuses": sorted({r["status"] for r in runs}),
        "wall_seconds": round(sum(r["seconds"] for r in runs), 2),
    }

def gate_b():
    """Contract: does the shape hold on the inputs I really send?"""
    violations = []
    for prompt in EDGE_PROMPTS:
        r = call(prompt)
        if r["status"] != 200:
            violations.append({"case": prompt[:24], "why": "status %s" % r["status"]})
            continue
        if prompt.startswith("Reply with JSON"):
            try:
                json.loads(r["text"] or "")
            except Exception:
                violations.append({"case": prompt[:24], "why": "not parseable JSON"})
    return {"cases": len(EDGE_PROMPTS), "violations": violations}

def gate_c():
    """Environment replay: fingerprint the machine, never the model text."""
    pkgs = subprocess.run([sys.executable, "-m", "pip", "freeze"],
                          capture_output=True, text=True).stdout
    return {
        "probe_sha": hashlib.sha256(open(__file__, "rb").read()).hexdigest()[:12],
        "packages_sha": hashlib.sha256(pkgs.encode()).hexdigest()[:12],
        "python": sys.version.split()[0],
    }

if __name__ == "__main__":
    receipt = {"gate_a": gate_a(), "gate_b": gate_b(), "gate_c": gate_c()}
    print(json.dumps(receipt, indent=2, sort_keys=True))

然后，在两个干净的环境中各运行一次：

# environment 1: your laptop
PROBE_BASE_URL="$BASE" PROBE_API_KEY="$KEY" PROBE_MODEL="$MODEL" \
  python probe.py > receipt-a.json

# environment 2: a clean container, clean venv
PROBE_BASE_URL="$BASE" PROBE_API_KEY="$KEY" PROBE_MODEL="$MODEL" \
  python probe.py > receipt-b.json

# compare the machine, not the sentence
diff <(jq -S .gate_c receipt-a.json) <(jq -S .gate_c receipt-b.json)
diff <(jq -S .gate_a.statuses receipt-a.json) \
     <(jq -S .gate_a.statuses receipt-b.json)

注意三件事。Gate A 给你的是状态码集合，不是平均值。Gate B 给你的是明确标出具体用例的违规记录，不是分数。Gate C 给你的是两个可以用 diff 比较的哈希值。

任何检测报告都不应包含你的 API key，也不应包含真实客户的 prompt。提交任何内容之前，先做脱敏。

我按这个顺序阅读报告。A 的检查成本最低，C 则是大家最容易跳过的。

中间那一项，是我最常遇到问题的地方。端点从来都不是问题所在，问题在于我对 schema 的预期。

把局限说清楚

这个探测脚本衡量的是服务能否响应、输出结构是否符合要求，以及环境是否一致。它不衡量回答质量。一份全绿的报告，只能说明管道接通了，不能说明水是干净的。

N=8 是冒烟测试，不是负载测试。可以把它调大，但要让运行成本保持足够低，确保每次发布都能跑。

免费端点会变化。检测报告是一张标有日期的照片，不是一份承诺。要重新运行检查。

Gate C 就是用来比较环境的。如果你想比较文本，请放到自己的测试套件中，在那里自行控制断言。

Gate A 中的实际耗时，只用于发现性能回退，不是延迟基准测试。

哪些人不适合用这个方法

如果你需要合同承诺的可用性指标，就别用这个方法。免费套餐给不了这种承诺，任何探测脚本也补不上。去购买带有支持条款的服务。

如果你的 prompt 包含受监管的数据，就别用这个方法。在你还没摸清各道关卡的边界时，不要把这些数据发到共享端点。

如果团队里没人会看检测报告，就别用这个方法。没人读的产物，只是多绕了几道工序的日志噪声。

免费访问在哪个阶段最有价值

披露：本文是 MonkeyCode 产品推广活动的一部分。

MonkeyCode 提供免费模型访问，也提供免费服务器选项。在这个工作流还没有得到验证的时候，我同时使用了两者，而这恰好就是它们最适合发挥作用的阶段。还没拿到检测报告就为容量付费，是在猜；拿到报告后再付费，才是在做决策。

这套探测方法依然适用。免费访问和免费服务器会各自独立出问题，这也是误区 2 在这里很重要的原因。我遇到 Gate A 亮红灯时，问题出在自己的超时设置。Gate C 亮红灯时，问题出在镜像，而不是端点。这正是把它们拆开检查的全部意义。

免费资源是验证场，不是长期方案。用它找出那些你还不知道的问题。

真正重要的习惯

别再把一次成功响应当成证据。收集状态码集合，明确记录输出结构违规的具体情况，为机器生成指纹。

如果你写了这个探测脚本，就把检测报告和它所描述的工作流放在一起提交。未来的你，会希望报告上留着日期。

如需采取进一步措施，你可以考虑屏蔽此人和／或举报滥用行为。