# ChatGPT部署

***Copyright © Quectel Wireless Solutions Co., Ltd. 2026. All rights reserved.***

---

## **ChatGPT 介绍**

ChatGPT 是 OpenAI 推出的基于 GPT（Generative Pre-trained Transformer）架构的对话式大语言模型产品，代表模型包括 GPT-3.5-turbo、GPT-4、GPT-4o、GPT-4o-mini 等。它具备多轮对话、代码生成、逻辑推理、多模态理解等能力，是目前应用最广泛的商用 LLM 之一。

本文档演示如何在 **Quectel Pi M1** 智能主控板本地部署ChatGPT。

### **部署所需资源介绍**

由于 ChatGPT 是闭源云服务，"部署 ChatGPT" 的本质是 **在设备上部署一个调用 OpenAI API 的本地服务网关**，使设备及其局域网内的客户端能够通过该网关进行问答。

## **ChatGPT 模型介绍**

OpenAI API 当前可供调用的主流模型：

| **模型** | **上下文窗口** | **说明** | **适用场景** |
| --- | --- | --- | --- |
| `gpt-4o` | 128K | 最新多模态旗舰模型，支持文本/图像输入 | 复杂推理、多模态 |
| `gpt-4o-mini` | 128K | 4o 的小尺寸版本，速度快、价格低 | 通用对话（推荐默认） |
| `gpt-4-turbo` | 128K | GPT-4 长上下文版本 | 长文档分析 |
| `gpt-4` | 8K/32K | 经典 GPT-4 | 高质量推理 |
| `gpt-3.5-turbo` | 16K | 老牌经济型模型 | 低成本简单任务 |

> 嵌入式设备场景下推荐默认使用 `gpt-4o-mini`，兼顾质量、速度与成本。

## **部署模型特性指标**

由于采用 API 调用方式，本地不加载模型权重，指标主要取决于网络与服务端：

| **指标** | **典型值** | **备注** |
| --- | --- | --- |
| 本地内存占用 | ~30-50 MB | Python 进程 + 依赖 |
| 本地 CPU 占用 | < 5% | 仅做请求转发 |
| 首字延迟（TTFT） | 0.5-2 s | 取决于网络与服务端负载 |
| 生成速度 | 30-80 tokens/s | 服务端生成，受网络限速 |
| 单次最大输入 | 128K tokens（4o 系列） | 受模型上下文窗口限制 |
| 并发能力 | 受 API 速率限制（RPM/TPM） | 与账户等级相关 |
| 离线可用性 | 不可用 | 必须联网 |

## **安装**

### **依赖下载**

ChatGPT 网关服务依赖 Python 3 及 `openai` 官方库。M1 已预装 Python 3.13.5 与 pip3，仅需安装 Python 依赖。

```bash
# 1. 确认 Python 与 pip
python3 --version    # 应输出 Python 3.13.5
pip3 --version

# 2. 升级 pip 并安装 openai 官方库（API 调用）与 flask（本地网关）
pip3 install --upgrade pip
pip3 install openai flask

# 3. 验证安装
python3 -c "import openai; print('openai', openai.__version__)"
```

> 若 pip 安装报证书错误，可加 `--trusted-host pypi.org --trusted-host files.pythonhosted.org`。
> 若需要离线安装，可在联网主机 `pip download openai flask -d ./wheels` 后将 wheels 目录 `adb push` 到设备，再 `pip3 install --no-index --find-links=./wheels openai flask`。

### **工具下载**

下载CURL工具

```bash
apt install curl
curl --version | head -1    # 确认 curl 可用
```

如需在设备上做流式可视化测试，可选安装 `jq`（JSON 处理）：

```bash
apt-get install -y jq       # 设备为 Debian，apt 可用
```

### **模型下载选择**

**重要说明：** ChatGPT（GPT-4 / GPT-3.5 等）是 OpenAI 的闭源商业模型，**模型权重无法下载、无法在本地运行**。因此本节"模型选择"指 **选择调用哪个 OpenAI API 模型**，而非下载模型文件。

选择建议：

- **\*\*默认推荐：`gpt-4o-mini`\*\*** —— 速度快、价格低、支持 128K 上下文，适合嵌入式设备的多数对话场景

- **\*\*高质量推理：`gpt-4o`\*\*** —— 复杂逻辑/代码任务，延迟与成本较高

- **\*\*低成本简单任务：`gpt-3.5-turbo`\*\*** —— 历史经济型模型

若需 **完全离线** 运行 GPT 风格模型，可改用开源替代方案（如 GPT-2 117M、Qwen2.5-0.5B 等），通过 llama.cpp 在本地加载 GGUF 文件。此类方案不依赖网络但质量与 ChatGPT 有差距

## **启动**

### **后台部署及部署配置介绍**

下面在设备 `/data/chatgpt/` 下部署一个 **OpenAI 兼容的本地网关服务**。它对外暴露 HTTP 接口，内部转发到 OpenAI API，并支持多轮对话与流式输出。

**目录结构：**

```plaintext
/data/chatgpt/
├── config.env          # 配置文件（API Key、模型、端口等）
├── chatgpt_server.py   # 网关服务主程序
└── chatgpt.service     # systemd 服务单元（后台常驻）
```

**步骤 1：创建目录与配置文件**

```bash
mkdir -p /data/chatgpt
cat > /data/chatgpt/config.env <<'EOF'
# ===== ChatGPT 网关配置 =====
# OpenAI API Key（必填，替换为自己的 Key）
export OPENAI_API_KEY="sk-在此填入你的OpenAI密钥"

# API 基础地址：默认官方，如使用中转服务则改为对应地址
# 官方：https://api.openai.com/v1
# 中转示例：https://your-proxy.example.com/v1
export OPENAI_BASE_URL="https://api.openai.com/v1"

# 默认模型
export CHATGPT_MODEL="gpt-4o-mini"

# 网关监听地址与端口（0.0.0.0 表示允许局域网访问）
export SERVER_HOST="0.0.0.0"
export SERVER_PORT="8000"

# 系统提示词（定义助手人设）
export SYSTEM_PROMPT="你是一个运行在嵌入式设备上的智能助手，请简洁专业地回答问题。"

# 采样参数
export TEMPERATURE="0.7"
export MAX_TOKENS="1024"
EOF
chmod 600 /data/chatgpt/config.env   # 保护密钥
```

**步骤 2：编写网关服务主程序**

```bash
cat > /data/chatgpt/chatgpt_server.py <<'PYEOF'
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""ChatGPT 网关服务：对外暴露 HTTP 接口，转发至 OpenAI API。
   提供两种接口：
     /v1/chat/completions  —— OpenAI 兼容接口（可被任意 OpenAI 客户端调用）
     /ask                  —— 极简问答接口（GET/POST，便于嵌入式调用）
"""
import os, json, uuid
from flask import Flask, request, Response, jsonify
from openai import OpenAI

# ---- 加载配置 ----
CFG_PATH = "/data/chatgpt/config.env"
if os.path.exists(CFG_PATH):
    for line in open(CFG_PATH, encoding="utf-8"):
        line = line.strip()
        if line and not line.startswith("#") and "=" in line and line.startswith("export "):
            k, v = line[len("export "):].split("=", 1)
            os.environ.setdefault(k.strip(), v.strip().strip('"').strip("'"))

API_KEY     = os.environ["OPENAI_API_KEY"]
BASE_URL    = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1")
MODEL       = os.environ.get("CHATGPT_MODEL", "gpt-4o-mini")
HOST        = os.environ.get("SERVER_HOST", "0.0.0.0")
PORT        = int(os.environ.get("SERVER_PORT", "8000"))
SYS_PROMPT  = os.environ.get("SYSTEM_PROMPT", "You are a helpful assistant.")
TEMPERATURE = float(os.environ.get("TEMPERATURE", "0.7"))
MAX_TOKENS  = int(os.environ.get("MAX_TOKENS", "1024"))

client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
app = Flask(__name__)

# 会话存储（演示用，进程内字典；生产环境建议持久化）
sessions = {}

def build_messages(sid, user_msg):
    if sid not in sessions:
        sessions[sid] = [{"role": "system", "content": SYS_PROMPT}]
    sessions[sid].append({"role": "user", "content": user_msg})
    return sessions[sid]

@app.route("/ask", methods=["POST"])
def ask_simple():
    """极简接口：POST /ask  body={"q":"你的问题","sid":"可选会话id"}"""
    data = request.get_json(force=True, silent=True) or {}
    q   = data.get("q", "").strip()
    sid = data.get("sid", "default")
    if not q:
        return jsonify({"error": "missing 'q'"}), 400
    try:
        msgs = build_messages(sid, q)
        resp = client.chat.completions.create(
            model=MODEL, messages=msgs,
            temperature=TEMPERATURE, max_tokens=MAX_TOKENS)
        ans = resp.choices[0].message.content
        sessions[sid].append({"role": "assistant", "content": ans})
        return jsonify({"answer": ans, "model": MODEL})
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route("/v1/chat/completions", methods=["POST"])
def chat_completions():
    """OpenAI 兼容接口，支持 stream。"""
    body = request.get_json(force=True, silent=True) or {}
    msgs = body.get("messages", [])
    stream = body.get("stream", False)
    model  = body.get("model", MODEL)
    # 自动补系统提示
    if not msgs or msgs[0].get("role") != "system":
        msgs = [{"role": "system", "content": SYS_PROMPT}] + msgs
    try:
        if not stream:
            r = client.chat.completions.create(
                model=model, messages=msgs,
                temperature=body.get("temperature", TEMPERATURE),
                max_tokens=body.get("max_tokens", MAX_TOKENS))
            return jsonify(r.model_dump())
        # 流式
        def gen():
            r = client.chat.completions.create(
                model=model, messages=msgs, stream=True,
                temperature=body.get("temperature", TEMPERATURE),
                max_tokens=body.get("max_tokens", MAX_TOKENS))
            for chunk in r:
                yield f"data: {json.dumps(chunk.model_dump(), ensure_ascii=False)}\n\n"
            yield "data: [DONE]\n\n"
        return Response(gen(), mimetype="text/event-stream")
    except Exception as e:
        return jsonify({"error": {"message": str(e)}}), 500

@app.route("/v1/models", methods=["GET"])
def list_models():
    """返回可用模型列表（OpenAI 兼容）。"""
    try:
        return jsonify(client.models.list().model_dump())
    except Exception as e:
        return jsonify({"error": str(e)}), 500

@app.route("/health", methods=["GET"])
def health():
    return jsonify({"status":"ok","model":MODEL,"base_url":BASE_URL})

if __name__ == "__main__":
    print(f"[ChatGPT Gateway] model={MODEL} base={BASE_URL} listen={HOST}:{PORT}")
    app.run(host=HOST, port=PORT, threaded=True)
PYEOF
chmod +x /data/chatgpt/chatgpt_server.py
```

**步骤 3：配置 systemd 后台服务（开机自启）**

```bash
cat > /data/chatgpt/chatgpt.service <<'EOF'
[Unit]
Description=ChatGPT Gateway Service on SC200U
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
WorkingDirectory=/data/chatgpt
EnvironmentFile=/data/chatgpt/config.env
ExecStart=/usr/bin/python3 /data/chatgpt/chatgpt_server.py
Restart=on-failure
RestartSec=5
StandardOutput=append:/data/chatgpt/chatgpt.log
StandardError=append:/data/chatgpt/chatgpt.log

[Install]
WantedBy=multi-user.target
EOF

# 安装并启用服务
cp /data/chatgpt/chatgpt.service /etc/systemd/system/chatgpt.service
systemctl daemon-reload
systemctl enable chatgpt.service
```

### **启动 ChatGPT 服务**

**首次启动前必须配置 API Key：**

```bash
# 编辑配置，填入真实 Key
vi /data/chatgpt/config.env
# 修改 OPENAI_API_KEY="sk-你的真实密钥"
```

**启动与管理：**

```bash
# 启动服务
systemctl start chatgpt.service

# 查看状态
systemctl status chatgpt.service

# 查看日志
tail -f /data/chatgpt/chatgpt.log

# 重启 / 停止
systemctl restart chatgpt.service
systemctl stop chatgpt.service
```

**手动前台调试（不经过 systemd）：**

```bash
cd /data/chatgpt
source ./config.env
python3 ./chatgpt_server.py
```

启动成功后日志会输出：

```plaintext
[ChatGPT Gateway] model=gpt-4o-mini base=https://api.openai.com/v1 listen=0.0.0.0:8000
 * Running on http://0.0.0.0:8000
```

## **应用演示**

### **健康检查**

```bash
curl http://127.0.0.1:8000/health
# {"model":"gpt-4o-mini","status":"ok","base_url":"https://api.openai.com/v1"}
```

### **极简单轮问答**

```bash
curl -s -X POST http://127.0.0.1:8000/ask \
  -H "Content-Type: application/json" \
  -d '{"q":"用一句话介绍SC200U芯片"}' | python3 -m json.tool
```

预期输出：

```json
{
    "answer": "SC200U是移远通信基于高通骁龙的物联网通信模组，支持4G全网通与边缘智能。",
    "model": "gpt-4o-mini"
}
```

### **嵌入式程序调用示例（C / curl）**

设备上的 C 程序或 shell 脚本可通过 curl 调用：

```bash
# shell 一行调用
ANSWER=$(curl -s -X POST http://127.0.0.1:8000/ask \
  -H "Content-Type: application/json" \
  -d "{\"q\":\"${QUERY}\"}" | python3 -c "import sys,json;print(json.load(sys.stdin)['answer'])")
echo "$ANSWER"
```

## **应用场景**

| **场景** | **说明** |
| --- | --- |
| **智能客服终端** | 在 SC200U 智能网关/POS 设备上提供自然语言问答，处理用户咨询 |
| **工业现场语音助手** | 结合 ASR/TTS，工程师通过语音询问设备故障排查建议 |
| **代码/脚本生成** | 现场运维时让模型生成 shell/Python 脚本片段 |

## **常见问题**

### **模型过大**

ChatGPT 本身无法本地化，但若场景要求 **完全离线** 或 **零 API 成本**，可在 M1上部署开源小模型替代。本设备可运行的最小方案：

| **替代模型** | **参数量** | **GGUF 量化** | **内存占用** | **推理速度(SC200U)** | **质量** |
| --- | --- | --- | --- | --- | --- |
| GPT-2 | 124M | F16 | ~0.5 GB | ~15-30 tok/s | 低（仅英文短文） |
| Qwen2.5-0.5B | 0.5B | Q4_K_M | ~0.6 GB | ~8-15 tok/s | 中 |
| DeepSeek-R1-Distill-Qwen-1.5B | 1.5B | Q4_K_M | ~1.6 GB | ~3-8 tok/s | 中高（推理强） |
| Qwen2.5-1.5B | 1.5B | Q4_K_M | ~1.6 GB | ~3-8 tok/s | 中高 |
| Qwen2.5-3B | 3B | Q4_K_M | ~2.6 GB | ~1-3 tok/s | 高（需 Swap，较卡） |

> 7B 及以上模型在 3.7GB 内存设备上不可行（会触发 OOM）。