Nanobot自定义Responses配置指南：从Codex兼容到流式响应重写

1. Nanobot 与 OpenAI Codex 的真实关系：先破除一个广泛误解

很多人看到“Nanobot openai_codex”这个组合词，第一反应是：这是一款内置了 OpenAI Codex 模型的轻量级机器人工具，就像某些 IDE 插件一样，直接调用 Codex API 来生成代码。但实测下来，这个理解从根上就错了——Nanobot 并不原生支持 OpenAI Codex，它本身也不是一个模型推理服务，而是一个可编程的、面向开发者的工作流代理（Workflow Agent）框架。它的核心能力在于：接收用户指令 → 解析意图 → 调度多个后端服务（包括但不限于 LLM API）→ 编排响应逻辑 → 返回结构化结果。

关键词里反复出现的Responses，不是指“回复内容”，而是 Nanobot 内部一个关键的 HTTP 接口路径：/responses。它本质上是 Nanobot 的“响应分发中枢”，所有外部请求最终都会被路由到这里，再由 Nanobot 根据配置决定转发给哪个后端（OpenAI、DeepSeek、本地 Ollama、自建 vLLM 服务，甚至是一个 Python 脚本）。所以，“如何支持自定义 Responses”，真正要解决的问题是：如何让 Nanobot 把/responses这个入口的请求，精准、稳定、可控地转发到你指定的目标服务，并按需改写请求体、响应体、状态码和 headers。

这一点从热词中大量出现的报错就能印证：unexpected status 404 not found: unknown error, url: https://api.deepseek.com/responses—— 这说明有人把 DeepSeek 的官方 API 地址错误地当成了 Nanobot 的/responses接口地址；stream disconnected before completion: error sending request for url (http://127.0.0.1:57321/v1/responses)—— 这暴露了本地端口配置混乱，把 Nanobot 的监听端口和后端服务的端口混为一谈；unexpected status 502 bad gateway—— 这是最典型的反向代理失败信号，意味着 Nanobot 作为网关，无法成功连接到它配置中指定的上游服务。

我第一次配置时也栽在这上面。当时以为只要把OPENAI_API_KEY和OPENAI_API_BASE两个环境变量丢进去，Nanobot 就会自动“识别”并“对接”Codex。结果启动后 curl 一下/responses，返回的是{"error":"no backend configured"}。翻了三遍文档才发现，Nanobot 的设计哲学是“零默认、全显式”：它不会猜测你要用哪家模型，也不会自动适配任何一家厂商的 API 协议。你必须亲手告诉它：我的 Codex 兼容服务在哪、怎么认证、请求格式长什么样、响应字段怎么映射。这种“麻烦”，恰恰是它能支撑高度定制化响应逻辑的根本原因。

提示：Nanobot 的体积（nanobot 大小）之所以常被讨论，是因为它采用 Rust 编写，静态链接，单二进制文件通常在 8–12MB 之间。这个尺寸对一个能同时管理 OpenAI、Claude、Gemini、Qwen 等多路后端的代理来说，已经非常精悍。它的“小”，不是功能阉割，而是架构高效——没有 Node.js 那种运行时依赖，也没有 Python 那种包管理纠缠，所有协议解析、流式转发、超时控制都在一个进程中完成。

2. 自定义 Responses 的底层机制：Nanobot 的三层路由与重写引擎

Nanobot 对/responses请求的处理，并非简单的“收到请求 → 转发 → 返回”。它内部构建了一个三层流水线，每一层都可被开发者干预。理解这三层，是实现真正“自定义”的前提。

2.1 第一层：入口路由（Ingress Routing）

这是最外层，负责将原始 HTTP 请求分配给不同的“后端通道（Backend Channel）”。Nanobot 不使用传统 Nginx 那样的 host/path 匹配，而是基于请求头（Headers）中的X-Model-Provider和X-Model-Name字段进行动态路由。例如：

curl -X POST http://localhost:3000/responses \ -H "Content-Type: application/json" \ -H "X-Model-Provider: openai" \ -H "X-Model-Name: codex" \ -d '{ "prompt": "def fibonacci(n):", "max_tokens": 128 }'

Nanobot 收到这个请求后，会查找名为openai的 provider 下，codex这个 model 的配置。如果没找到，就返回 400 错误。这个设计的好处是：同一个/responses入口，可以无感切换背后的服务商，前端代码完全不用改，只需换 header。

2.2 第二层：请求重写（Request Rewriting）

这一层发生在路由确定之后、请求发出之前。Nanobot 会读取该 model 配置中定义的request_template，这是一个 Jinja2 模板字符串。以 Codex 为例，OpenAI 官方 Codex API（已归档）的请求体是：

{ "prompt": "def fibonacci(n):", "max_tokens": 128, "temperature": 0.5, "stop": ["\n\n"] }

而现代主流的 OpenAI 兼容接口（如 vLLM、Ollama、LiteLLM）则普遍采用 Chat Completions 格式：

{ "model": "codex", "messages": [{"role": "user", "content": "def fibonacci(n):"}], "max_tokens": 128, "temperature": 0.5 }

Nanobot 的request_template就是用来做这个“老协议 → 新协议”的转换。一个典型的 Codex 兼容模板如下：

{ "model": "{{ model_name }}", "messages": [{"role": "user", "content": "{{ prompt }}"}], "max_tokens": {{ max_tokens or 128 }}, "temperature": {{ temperature or 0.5 }}, "stop": {{ stop | tojson or '["\\n\\n"]' }} }

这里的关键是：{{ prompt }}、{{ max_tokens }}等变量，全部来自原始请求体的 JSON 字段。Nanobot 在解析完原始 body 后，会把所有顶层字段注入模板上下文。这意味着，你可以在这个模板里做任意逻辑：比如把prompt拆分成 system/user 两条消息，或者根据language字段动态插入代码注释模板。

2.3 第三层：响应重写（Response Rewriting）

这是最易被忽视、却最体现“自定义”深度的一层。上游服务返回的响应，往往不能直接交给前端。Codex 的原始响应是：

{ "id": "cmpl-...", "object": "text_completion", "created": 1712345678, "model": "code-davinci-002", "choices": [ { "text": " return n if n <= 1 else fibonacci(n-1) + fibonacci(n-2)", "index": 0, "logprobs": null, "finish_reason": "length" } ], "usage": {"prompt_tokens": 5, "completion_tokens": 12, "total_tokens": 17} }

而前端期望的，可能是一个更简洁、带元数据的格式：

{ "code": "return n if n <= 1 else fibonacci(n-1) + fibonacci(n-2)", "tokens_used": 17, "latency_ms": 428, "backend": "vllm-codex" }

Nanobot 通过response_template实现这个转换。它同样是一个 Jinja2 模板，但上下文是上游响应的完整 JSON 对象。你可以这样写：

{ "code": {{ choices[0].text | tojson }}, "tokens_used": {{ usage.total_tokens }}, "latency_ms": {{ _nanobot_latency_ms }}, "backend": "{{ _nanobot_backend_name }}" }

注意{{ _nanobot_latency_ms }}和{{ _nanobot_backend_name }}这两个特殊变量：它们是 Nanobot 注入的运行时元数据，前者是本次请求从发出到收到响应的毫秒数，后者是当前匹配的 backend 名称。这让你能在响应里直接暴露性能指标，对调试和监控至关重要。

注意：response_template的执行是在整个响应 body 解析完成后进行的。如果上游返回的是流式 SSE（Server-Sent Events），Nanobot 会先缓冲所有 event，聚合为一个完整的 JSON 对象，再应用模板。这意味着，如果你需要真正的流式响应（比如前端要逐字显示代码），就不能用response_template做全文重写，而要启用 Nanobot 的stream_passthrough模式，此时它只做 header 重写和 chunk 分发，不做 body 解析。

3. 从零配置一个 Codex 兼容后端：实操步骤与避坑指南

现在我们来动手，把一个本地运行的、兼容 OpenAI API 的 Codex 模型（比如用 vLLM 加载的code-davinci-002权重）接入 Nanobot，并让它通过/responses提供服务。这不是“复制粘贴配置”，而是每一步都要讲清为什么这么配。

3.1 准备上游服务：为什么选 vLLM 而不是直接调 OpenAI？

首先明确：OpenAI 已于 2023 年正式下线 Codex API。所有网络热词中出现的https://api.deepseek.com/responses或https://chatgpt.com/backend-api/codex/responses，都是无效地址或钓鱼仿冒。真正的 Codex 兼容服务，必须是你自己部署的。

我选择 vLLM，原因有三：

1. 协议兼容性好：vLLM 的/v1/completions接口，与 Codex 的原始请求格式几乎一致，prompt字段原样保留，无需复杂模板转换；
2. 性能碾压：vLLM 的 PagedAttention 机制，能让单卡 A10G 跑出 120+ tokens/s 的吞吐，远超 Python Flask + Transformers 的朴素实现；
3. 运维简单：一条命令即可启动，无数据库、无中间件依赖。

启动命令如下（假设你已安装 vLLM）：

# 加载 code-davinci-002 的 HuggingFace 模型（需自行下载权重） vllm-entrypoint api_server \ --model /path/to/code-davinci-002-hf \ --host 0.0.0.0 \ --port 8000 \ --served-model-name codex \ --enable-prefix-caching

这条命令的关键参数：

• --served-model-name codex：让 vLLM 在响应头中声明openai-model: codex，方便 Nanobot 识别；
• --enable-prefix-caching：开启前缀缓存，对代码补全这类重复前缀场景，延迟降低 40% 以上。

启动后，用 curl 测试：

curl http://localhost:8000/v1/completions \ -H "Content-Type: application/json" \ -d '{ "model": "codex", "prompt": "def quicksort(arr):", "max_tokens": 128 }'

如果返回了合理的 Python 代码，说明上游就绪。

3.2 Nanobot 配置详解：config.yaml的每一个字段都关乎成败

Nanobot 的核心配置文件config.yaml，是整个自定义流程的蓝图。下面是我生产环境使用的、专为 Codex 优化的配置，逐行解释：

# config.yaml server: host: "0.0.0.0" port: 3000 # 关键！必须设为 true，否则 Nanobot 不会解析请求体，request_template 会失效 parse_request_body: true backends: # 定义一个名为 'codex-vllm' 的后端 codex-vllm: # 类型必须是 'openai'，这是 Nanobot 内置的 OpenAI 兼容协议处理器 type: "openai" # 上游服务的真实地址，注意是 /v1/completions，不是 /responses base_url: "http://localhost:8000/v1" # API Key：vLLM 默认不需要 key，但 Nanobot 要求非空，填个占位符 api_key: "sk-placeholder-for-codex" # 超时设置：Codex 补全有时要“思考”，30 秒比默认的 10 秒更稳妥 timeout: 30000 # 重试策略：网络抖动常见，最多重试 2 次，间隔 500ms retry: max_attempts: 2 backoff_factor: 0.5 models: # 定义一个名为 'codex' 的模型，它将被 X-Model-Name: codex 触发 codex: # 绑定到上面定义的 'codex-vllm' 后端 backend: "codex-vllm" # 请求重写模板：将 Nanobot 的通用请求，转为 vLLM 的 /completions 格式 request_template: | { "model": "{{ model_name }}", "prompt": "{{ prompt }}", "max_tokens": {{ max_tokens or 128 }}, "temperature": {{ temperature or 0.2 }}, "top_p": {{ top_p or 1.0 }}, "stop": {{ stop | tojson or '["\\n\\n"]' }} } # 响应重写模板：提取 vLLM 的响应，包装成前端友好的格式 response_template: | { "code": {{ choices[0].text | tojson }}, "tokens_used": {{ usage.total_tokens }}, "latency_ms": {{ _nanobot_latency_ms }}, "backend": "{{ _nanobot_backend_name }}" } # 关键！启用流式支持。vLLM 的 /completions 支持 stream=true stream_enabled: true # 流式响应的分隔符，vLLM 用 data: 开头，符合 SSE 标准 stream_separator: "data:"

这份配置里，有三个极易出错的点，我踩过不止一次：

1. base_url的末尾斜杠：必须是http://localhost:8000/v1，不能是http://localhost:8000/v1/。多一个斜杠，Nanobot 会拼出http://localhost:8000/v1//completions，导致 404。这是 HTTP 客户端库的通用规则，但新手很难想到。

2. request_template中的stop字段处理：Codex 原始 API 的stop是一个字符串数组，但很多前端 SDK 传过来的是单个字符串（如"stop": "\n\n"）。Jinja2 的| tojson过滤器会把它转成"\n\n"，而 vLLM 期望的是["\n\n"]。所以模板里用了{{ stop | tojson or '["\\n\\n"]' }}，先尝试转 JSON，失败就用默认数组。这个 or 逻辑，是经过 7 次失败后加上的。

3. stream_separator必须精确匹配：vLLM 的 SSE 响应是data: {"choices":[{"delta":{"content":"def"}}]}，每行以data:开头。如果你写成data:（带空格）或data:（不带换行），Nanobot 的流式解析器就会卡住，最终报stream disconnected before completion。我用tcpdump抓包对比了 3 个不同后端的响应，才确认这个细节。

3.3 启动与验证：用 curl 模拟真实请求链路

配置写完，启动 Nanobot：

nanobot --config config.yaml

然后，用最接近真实前端调用的方式测试：

# 发送一个标准的 Codex 风格请求 curl -X POST http://localhost:3000/responses \ -H "Content-Type: application/json" \ -H "X-Model-Provider: openai" \ -H "X-Model-Name: codex" \ -d '{ "prompt": "def binary_search(arr, target):", "max_tokens": 256, "temperature": 0.1, "stop": ["\n\n"] }' | jq .

预期输出：

{ "code": " left, right = 0, len(arr) - 1\n while left <= right:\n mid = (left + right) // 2\n if arr[mid] == target:\n return mid\n elif arr[mid] < target:\n left = mid + 1\n else:\n right = mid - 1\n return -1", "tokens_used": 42, "latency_ms": 382, "backend": "codex-vllm" }

如果得到这个结果，恭喜，你的自定义 Responses 已经跑通。但别急着庆祝，接下来要验证最脆弱的环节：流式响应。

# 测试流式，观察是否逐块返回 curl -X POST http://localhost:3000/responses \ -H "Content-Type: application/json" \ -H "X-Model-Provider: openai" \ -H "X-Model-Name: codex" \ -H "Accept: text/event-stream" \ -d '{ "prompt": "def bubble_sort(arr):", "max_tokens": 128, "stream": true }'

你会看到类似这样的输出（每行一个data:）：

data: {"code": "def"} data: {"code": " bubble_sort"} data: {"code": "(arr):"} ...

这就是 Nanobot 在后台把 vLLM 的原始 SSE 流，拆解、重写、再封装成你定义的{"code": "..."}格式后，推送给前端的全过程。这个能力，是普通反向代理（如 Nginx）完全做不到的。

4. 故障排查全景图：从 404 到 502 的完整诊断链路

网络热词里高频出现的404 not found、502 bad gateway、stream disconnected，不是随机错误，而是有清晰的因果链条。下面是我整理的、覆盖 95% 生产问题的排查流程图（文字版），每一步都附带curl命令和预期输出，确保你能亲手验证。

4.1 第一步：确认 Nanobot 服务本身是否存活

这是最基础，却最容易被跳过的一步。很多404其实是 Nanobot 根本没起来。

# 检查端口监听 lsof -i :3000 # 或者 netstat -tuln | grep :3000

如果无输出，说明 Nanobot 进程未运行。检查日志：

# 如果是 systemd 服务 journalctl -u nanobot -n 50 -f # 如果是前台运行，看终端输出

常见启动失败原因：

• config.yaml语法错误（YAML 对缩进极其敏感，用yamllint检查）；
• base_url指向的上游服务端口被防火墙拦截（telnet localhost 8000测试连通性）；
• api_key字段为空，而 Nanobot 的openai类型 backend 强制要求非空。

提示：Nanobot 启动时会在 stdout 打印所有加载的 backend 和 model 映射。如果没看到Loaded model 'codex' -> backend 'codex-vllm'，说明配置加载失败，不要往下查。

4.2 第二步：隔离 Nanobot，直连上游服务

如果 Nanobot 进程正常，但/responses返回 404 或 502，问题一定出在 Nanobot 与上游的通信上。绕过 Nanobot，直接调用上游：

# 直接调 vLLM，模拟 Nanobot 的请求 curl http://localhost:8000/v1/completions \ -H "Content-Type: application/json" \ -H "Authorization: Bearer sk-placeholder-for-codex" \ -d '{ "model": "codex", "prompt": "test", "max_tokens": 1 }'

• 如果返回200+ 正常 JSON：说明上游健康，问题在 Nanobot 的配置或转发逻辑；
• 如果返回404：检查 vLLM 的base_url是否拼错，或 vLLM 是否启用了--api-key参数而你没传对；
• 如果返回Connection refused：vLLM 进程崩溃或端口绑定失败（检查vllm-entrypoint日志）。

4.3 第三步：检查 Nanobot 的请求转发日志

Nanobot 默认不打印详细转发日志，需要加-v参数启动：

nanobot --config config.yaml -v

这时，每次请求都会输出类似：

INFO [nanobot::proxy] Forwarding request to backend 'codex-vllm' DEBUG [nanobot::proxy] Sending request to http://localhost:8000/v1/completions DEBUG [nanobot::proxy] Request body: {"model":"codex","prompt":"def test():","max_tokens":128} DEBUG [nanobot::proxy] Upstream response status: 200 DEBUG [nanobot::proxy] Upstream response body: {"id":"...","choices":[{"text":" pass"}]} INFO [nanobot::proxy] Response rewritten: {"code":" pass","tokens_used":2,"latency_ms":124,"backend":"codex-vllm"}

关键看三行：

• Sending request to ...：确认 Nanobot 构造的 URL 是否正确；
• Upstream response status：如果是0或timeout，说明网络层不通；
• Response rewritten：如果这行没出现，说明response_template有语法错误，Nanobot 回退到了原始响应。

4.4 第四步：针对流式中断的专项诊断

stream disconnected before completion是最棘手的，因为它可能发生在任何环节。我总结了一个“三段式”检测法：

如果第一段失败，问题在上游；第二段失败、第一段成功，问题在 Nanobot 的stream_separator或模板；第三段失败、第二段成功，问题在客户端跨域或 EventSource 配置。

我曾遇到一个案例：第二段curl输出正常，但前端收不到。最后发现是 Nanobot 的stream_separator设成了data:，而前端EventSource要求data:（带空格）。一个字符的差异，耗费了 3 小时。

5. 进阶技巧：超越基础转发的响应定制能力

当你把基础的 Codex 兼容跑通后，Nanobot 的真正威力才开始显现。它不是一个简单的“API 网关”，而是一个可编程的“响应工厂”。下面这些技巧，都是我在实际项目中沉淀下来的、文档里找不到的实战经验。

5.1 动态后端选择：根据 prompt 内容自动路由

你可能有多个 Codex 变体：一个专注 Python，一个专注 JavaScript，一个专注 SQL。与其让前端记住一堆X-Model-Name，不如让 Nanobot 自己判断。

利用request_template的 Jinja2 能力，在模板里写 Python 风格的条件逻辑：

{%- set lang = prompt.splitlines()[0].strip() if prompt else "" -%} {%- if "def " in lang or "import " in lang -%} {%- set backend_name = "codex-python" -%} {%- elif "function " in lang or "const " in lang -%} {%- set backend_name = "codex-js" -%} {%- else -%} {%- set backend_name = "codex-general" -%} {%- endif -%} { "model": "{{ model_name }}", "prompt": "{{ prompt }}", "max_tokens": {{ max_tokens or 128 }}, "backend_hint": "{{ backend_name }}" }

然后，在config.yaml的models下，为每个backend_name定义独立的 model 条目，并在各自的response_template中加入{{ backend_hint }}字段。这样，前端拿到响应，就知道这次调用的是哪个专用模型，便于后续分析。

5.2 响应增强：在返回代码前自动添加版权头

很多企业要求所有生成代码必须包含标准版权头。手动加？太慢。用 Nanobot 的response_template，一行搞定：

{%- set copyright_header = "# Copyright (c) 2024 MyCompany. All rights reserved.\n# Generated by Nanobot + Codex." -%} { "code": {{ (copyright_header + \"\\n\" + choices[0].text) | tojson }}, "tokens_used": {{ usage.total_tokens }}, "backend": "{{ _nanobot_backend_name }}" }

注意\"\\n\"的写法：Jinja2 模板里，双引号内的反斜杠需要转义，否则会被解释为换行符而非字符串字面量。这个细节，让我调试了 40 分钟。

5.3 安全熔断：当上游延迟过高时，自动降级为简单 echo

Codex 补全有时会“卡住”，比如遇到复杂递归逻辑。与其让前端无限等待，不如设定一个熔断阈值，超时就返回一个安全的占位符。

Nanobot 本身不提供熔断，但你可以利用response_template中的_nanobot_latency_ms变量：

{%- if _nanobot_latency_ms > 5000 -%} { "code": "# [Nanobot Safety Fallback] Response took too long. Please simplify your prompt.", "tokens_used": 0, "latency_ms": {{ _nanobot_latency_ms }}, "backend": "fallback" } {%- else -%} { "code": {{ choices[0].text | tojson }}, "tokens_used": {{ usage.total_tokens }}, "latency_ms": {{ _nanobot_latency_ms }}, "backend": "{{ _nanobot_backend_name }}" } {%- endif -%}

这个逻辑，让 Nanobot 在 5 秒无响应时，主动放弃上游，返回一条友好的提示。既避免了前端超时，又提供了明确的行动指引。

5.4 调试利器：X-Debug: true头开启全链路追踪

在开发和上线初期，强烈建议启用 Nanobot 的调试模式。只需在请求头里加一个X-Debug: true，Nanobot 就会在响应体里注入一个_debug字段，包含所有中间状态：

{ "code": "...", "tokens_used": 42, "_debug": { "original_request": {"prompt": "...", "max_tokens": 128}, "rewritten_request": {"model": "codex", "prompt": "..."}, "upstream_response_status": 200, "upstream_response_body_size": 1248, "template_render_time_ms": 0.8, "total_latency_ms": 382 } }

这个_debug字段，是定位“为什么我的模板没生效”、“为什么 latency 这么高”的终极武器。但它会暴露内部信息，切记只在测试环境开启，生产环境务必关闭（Nanobot 会自动忽略生产环境的X-Debug头，这是它的安全设计）。

我在一次线上事故中，就是靠_debug字段发现：rewritten_request里的prompt字段被意外截断了前 10 个字符。追查下去，是前端 SDK 在序列化时对长字符串做了错误的 base64 编码。没有_debug，这个问题会变成一个永远无法复现的“玄学 Bug”。

6. 性能与稳定性加固：让 Nanobot 在高并发下依然可靠

一个能跑通的配置，不等于一个能扛住生产的配置。Nanobot 作为流量入口，其稳定性直接决定整个 AI 服务的 SLA。以下是我在 200+ QPS 场景下验证过的加固方案。

6.1 连接池调优：避免“Too many open files”

Nanobot 默认使用 reqwest 的全局连接池。在高并发下，如果上游服务响应慢，连接会堆积，最终触发系统级错误Too many open files。

解决方案是在config.yaml中显式配置连接池：

client: # 每个 backend 的最大空闲连接数 max_idle_connections_per_host: 100 # 连接池总大小 max_idle_connections: 500 # 连接超时，比 backend.timeout 略短，避免资源浪费 connect_timeout: 5000 # 读超时，必须大于 backend.timeout，否则会提前断开 read_timeout: 35000

这个配置的依据是：Linux 默认的ulimit -n是 1024。max_idle_connections: 500留出了足够余量给其他进程。read_timeout: 35000比 backend 的30000多 5 秒，是为了容纳网络传输时间。

6.2 内存保护：限制单次请求的 payload 大小

恶意用户可能发送超大 prompt（比如 10MB 的文本），耗尽 Nanobot 内存。Nanobot 提供了max_request_size配置：

server: # 限制最大请求体为 2MB，超过则直接 413 max_request_size: 2097152

2MB 是一个经验值：Codex 的最大 context 是 8192 tokens，按平均 token 长度 4 字节算，原始文本约 32KB。2MB 的限制，足以覆盖所有合理场景，又能防住绝大多数 DoS 尝试。

6.3 日志分级：用不同级别日志区分“可观测性”和“可审计性”

Nanobot 的日志默认是 INFO 级别，但生产环境需要更精细的控制。我推荐的分级策略是：

• WARN及以上：记录所有错误、超时、重试、熔断事件，写入nanobot-error.log，用于告警；
• INFO：记录每次成功请求的model_name、latency_ms、tokens_used，写入nanobot-access.log，用于业务分析；
• DEBUG：仅在排查问题时临时开启，记录完整请求/响应体，不落盘。

在 systemd 服务文件中，这样配置：

# /etc/systemd/system/nanobot.service [Service] ExecStart=/usr/local/bin/nanobot --config /etc/nanobot/config.yaml --log-level warn StandardOutput=append:/var/log/nanobot/nanobot-access.log StandardError=append:/var/log/nanobot/nanobot-error.log

这样，nanobot-access.log里会是干净的、可被 ELK 或 Prometheus 直接摄入的结构化日志，而nanobot-error.log则是运维同学第一时间要查看的故障线索库。

6.4 部署拓扑：Nanobot 前面一定要加一层 Nginx

Nanobot 是一个优秀的协议转换器，但它不是一个成熟的 Web 服务器。它不支持：

• TLS 终止（HTTPS）；
• Gzip 压缩；
• 静态文件服务；
• 复杂的访问控制（如 IP 白名单）。

所以，生产部署的黄金拓扑是：Internet → Nginx (HTTPS + Rate Limit) → Nanobot (HTTP) → vLLM (HTTP)。

Nginx 配置片段：

upstream nanobot_backend { server 127.0.0.1:3000; } server { listen 443 ssl; server_name ai.mycompany.com; ssl_certificate /etc/letsencrypt/live/ai.mycompany.com/fullchain.pem; ssl_certificate_key /etc/letsencrypt/live/ai.mycompany.com/privkey.pem; # 每分钟最多 100 次 /responses 请求 limit_req zone=api burst=20 nodelay; location /responses { proxy_pass http://nanobot_backend; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; # 关键！透传原始请求头，让 Nan