serve /model
  --trust-remote-code
  --dtype bfloat16
  --tensor-parallel-size 1
  --enable-auto-tool-choice
  --tool-call-parser qwen3_xml
  --reasoning-parser qwen3
  --max-model-len 65536
  --gpu-memory-utilization 0.75
  --max-num-seqs 8
  --served-model-name qwen3.6-27b
  --enable-prefix-caching
  --host 0.0.0.0
  --port 8000

curl -sS http://127.0.0.1:8000/v1/models

# New-API 大模型管理网关（SQLite 单机部署）
# 上游 vLLM：http://116.62.10.183:8000/v1
# 不设置 SQL_DSN 时，官方镜像默认使用 SQLite，库文件为 /data/one-api.db

services:
  new-api:
    image: calciumion/new-api:latest
    container_name: new-api
    restart: always
    command: --log-dir /app/logs
    ports:
      - "3000:3000"
    volumes:
      # SQLite 数据库、会话与用户数据
      - ./data:/data
      # 运行日志
      - ./logs:/app/logs
    environment:
      - TZ=Asia/Shanghai
    healthcheck:
      test: ["CMD-SHELL", "wget -q -O - http://localhost:3000/api/status | grep -o '\"success\":\\s*true' || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 20s

#!/bin/bash
# 在 116.62.10.183 上执行。数据目录会保留 SQLite 和日志。
set -eu
mkdir -p /opt/new-api/data /opt/new-api/logs
cd /opt/new-api
docker compose pull
docker compose up -d
docker compose ps
docker compose logs --tail 50

cd /opt/new-api
docker compose down

#!/usr/bin/env python3
"""在 New-API 中创建指向本机 vLLM 的 OpenAI 兼容渠道。重复执行会再新增一条渠道。"""
import json
import urllib.request

BASE = "http://127.0.0.1:3000"


def req(method, path, body=None, headers=None, timeout=120):
    data = None if body is None else json.dumps(body).encode()
    request = urllib.request.Request(BASE + path, data=data, method=method)
    request.add_header("Content-Type", "application/json")
    for key, value in (headers or {}).items():
        request.add_header(key, value)
    try:
        with urllib.request.urlopen(request, timeout=timeout) as resp:
            raw = resp.read().decode()
            return resp.status, json.loads(raw) if raw else {}
    except urllib.error.HTTPError as exc:
        raw = exc.read().decode()
        try:
            parsed = json.loads(raw)
        except json.JSONDecodeError:
            parsed = {"raw": raw[:500]}
        return exc.code, parsed


_, login = req(
    "POST",
    "/api/user/login",
    {"username": "admin", "password": "L4o4986784$"},
)
auth = {
    "Authorization": "Bearer " + login["data"]["access_token"],
    "New-Api-User": "1",
}
status, created = req(
    "POST",
    "/api/channel/",
    {
        "mode": "single",
        "channel": {
            "name": "vLLM-Qwen3.6-27B",
            "type": 1,
            "key": "sk-local-vllm",
            "base_url": "http://172.17.0.1:8000",
            "models": "qwen3.6-27b",
            "groups": ["default"],
            "group": "default",
            "priority": 0,
            "weight": 0,
            "status": 1,
        },
    },
    auth,
)
print("create", status, json.dumps(created, ensure_ascii=False)[:400])
status, channels = req("GET", "/api/channel/?p=1&page_size=20", headers=auth)
print("list", status, json.dumps(channels, ensure_ascii=False)[:800])

模型 qwen3.6-27b 的价格未配置。请前往「系统设置 → 运营设置」开启自用模式，或在「系统设置 → 分组与模型定价设置」中为该模型配置价格

#!/usr/bin/env python3
"""开启自用模式，并用管理员接口测试渠道 1。自用模式下未定价模型也可以调用。"""
import json
import urllib.request

BASE = "http://127.0.0.1:3000"


def req(method, path, body=None, headers=None, timeout=120):
    data = None if body is None else json.dumps(body).encode()
    request = urllib.request.Request(BASE + path, data=data, method=method)
    request.add_header("Content-Type", "application/json")
    for key, value in (headers or {}).items():
        request.add_header(key, value)
    try:
        with urllib.request.urlopen(request, timeout=timeout) as resp:
            raw = resp.read().decode()
            return resp.status, json.loads(raw) if raw else {}
    except urllib.error.HTTPError as exc:
        raw = exc.read().decode()
        try:
            parsed = json.loads(raw)
        except json.JSONDecodeError:
            parsed = {"raw": raw[:500]}
        return exc.code, parsed


_, login = req(
    "POST",
    "/api/user/login",
    {"username": "admin", "password": "L4o4986784$"},
)
auth = {
    "Authorization": "Bearer " + login["data"]["access_token"],
    "New-Api-User": "1",
}
status, updated = req(
    "PUT",
    "/api/option/",
    {"key": "SelfUseModeEnabled", "value": True},
    auth,
)
print("self-use", status, json.dumps(updated, ensure_ascii=False))
status, test = req(
    "GET",
    "/api/channel/test/1?model=qwen3.6-27b",
    headers=auth,
)
print("test", status, json.dumps(test, ensure_ascii=False)[:500])

#!/usr/bin/env python3
"""把令牌 1 改为永不过期、default 分组、无限额度，并重新启用。

更新接口默认不改 status。过期状态要在过期时间改成 -1 之后，
再单独调用 /api/token/?status_only=true。
"""
import json
import sqlite3
import urllib.request

BASE = "http://127.0.0.1:3000"


def req(method, path, body=None, headers=None, timeout=120):
    data = None if body is None else json.dumps(body).encode()
    request = urllib.request.Request(BASE + path, data=data, method=method)
    request.add_header("Content-Type", "application/json")
    for key, value in (headers or {}).items():
        request.add_header(key, value)
    try:
        with urllib.request.urlopen(request, timeout=timeout) as resp:
            raw = resp.read().decode()
            return resp.status, json.loads(raw) if raw else {}
    except urllib.error.HTTPError as exc:
        raw = exc.read().decode()
        try:
            parsed = json.loads(raw)
        except json.JSONDecodeError:
            parsed = {"raw": raw[:500]}
        return exc.code, parsed


_, login = req(
    "POST",
    "/api/user/login",
    {"username": "admin", "password": "L4o4986784$"},
)
auth = {
    "Authorization": "Bearer " + login["data"]["access_token"],
    "New-Api-User": "1",
}
status, updated = req(
    "PUT",
    "/api/token/",
    {
        "id": 1,
        "name": "api-key-v1",
        "status": 1,
        "expired_time": -1,
        "remain_quota": 500000,
        "unlimited_quota": True,
        "model_limits_enabled": False,
        "model_limits": "",
        "allow_ips": "",
        "group": "default",
    },
    auth,
)
print("update", status, json.dumps(updated, ensure_ascii=False)[:400])
status, enabled = req(
    "PUT",
    "/api/token/?status_only=true",
    {"id": 1, "status": 1},
    auth,
)
print("enable", status, json.dumps(enabled, ensure_ascii=False)[:400])

con = sqlite3.connect("/opt/new-api/data/one-api.db")
key = con.execute("SELECT key FROM tokens WHERE id=1").fetchone()[0]
status, chat = req(
    "POST",
    "/v1/chat/completions",
    {
        "model": "qwen3.6-27b",
        "messages": [{"role": "user", "content": "只回复：ok"}],
        "max_tokens": 16,
    },
    {"Authorization": "Bearer sk-" + key},
)
print("chat", status)
if "error" in chat:
    print(json.dumps(chat["error"], ensure_ascii=False)[:400])
else:
    choice = (chat.get("choices") or [{}])[0]
    message = choice.get("message") or {}
    print("finish", choice.get("finish_reason"))
    print("content", repr((message.get("content") or "")[:120]))

This model's maximum context length is 65536 tokens.
However, you requested 32000 output tokens and your prompt contains at least 33537 input tokens,
for a total of at least 65537.

{
  "说明": "这是 Cline 模型目录里 qwen3.6-27b 改过之后的片段。实际文件是 C:\\Users\\DCKJ\\.cline\\data\\settings\\models.json。请求地址不在这个文件里，而在 providers.json 的 openai-compatible.settings.baseUrl。",
  "qwen3.6-27b": {
    "id": "qwen3.6-27b",
    "name": "qwen3.6-27b",
    "contextWindow": 65536,
    "maxInputTokens": 57344,
    "maxTokens": 8192,
    "capabilities": ["streaming", "tools", "images"]
  },
  "cline实际请求": {
    "baseUrl": "http://10.0.1.47:3000/v1",
    "model": "qwen3.6-27b",
    "配置文件": "C:\\Users\\DCKJ\\.cline\\data\\settings\\providers.json"
  }
}

尚未启用在线充值。请使用兑换码或联系管理员。

#!/usr/bin/env python3
"""确认支付合规声明。确认后兑换码可用；在线充值仍要另配支付商户。"""
import json
import urllib.request

BASE = "http://127.0.0.1:3000"


def req(method, path, body=None, headers=None, timeout=30):
    data = None if body is None else json.dumps(body).encode()
    request = urllib.request.Request(BASE + path, data=data, method=method)
    request.add_header("Content-Type", "application/json")
    for key, value in (headers or {}).items():
        request.add_header(key, value)
    with urllib.request.urlopen(request, timeout=timeout) as resp:
        return json.loads(resp.read().decode())


login = req(
    "POST",
    "/api/user/login",
    {"username": "admin", "password": "L4o4986784$"},
)
auth = {
    "Authorization": "Bearer " + login["data"]["access_token"],
    "New-Api-User": "1",
}
confirmed = req("POST", "/api/option/payment_compliance", {"confirmed": True}, auth)
print("compliance", json.dumps(confirmed, ensure_ascii=False)[:400])
info = req("GET", "/api/user/topup/info", headers=auth)
data = info.get("data") or {}
print(
    json.dumps(
        {
            "enable_online_topup": data.get("enable_online_topup"),
            "enable_redemption": data.get("enable_redemption"),
            "payment_compliance_confirmed": data.get("payment_compliance_confirmed"),
            "pay_methods": data.get("pay_methods"),
        },
        ensure_ascii=False,
    )
)

http://116.62.10.183:3000/sign-up?aff=Bk4J

#!/usr/bin/env python3
"""把邀请奖励设为 500000（页面上的 $1），并补记当时已经注册但没发奖的 zhenjiang。

只在 wanyan.aff_count 仍为 0 时补记，避免重复加奖。
"""
import json
import sqlite3
import urllib.request

BASE = "http://127.0.0.1:3000"
REWARD = 500000


def req(method, path, body=None, headers=None, timeout=30):
    data = None if body is None else json.dumps(body).encode()
    request = urllib.request.Request(BASE + path, data=data, method=method)
    request.add_header("Content-Type", "application/json")
    for key, value in (headers or {}).items():
        request.add_header(key, value)
    with urllib.request.urlopen(request, timeout=timeout) as resp:
        return json.loads(resp.read().decode())


login = req(
    "POST",
    "/api/user/login",
    {"username": "admin", "password": "L4o4986784$"},
)
auth = {
    "Authorization": "Bearer " + login["data"]["access_token"],
    "New-Api-User": "1",
}
for key in ("QuotaForInviter", "QuotaForInvitee"):
    result = req("PUT", "/api/option/", {"key": key, "value": str(REWARD)}, auth)
    print(key, result.get("success"), result.get("message"))

con = sqlite3.connect("/opt/new-api/data/one-api.db")
con.execute("BEGIN")
inviter = con.execute(
    "SELECT aff_count FROM users WHERE id=2 AND username='wanyan'"
).fetchone()
invitee = con.execute(
    "SELECT inviter_id FROM users WHERE id=3 AND username='zhenjiang'"
).fetchone()
if inviter and inviter[0] == 0 and invitee and invitee[0] == 2:
    con.execute(
        "UPDATE users SET aff_count=aff_count+1, aff_quota=aff_quota+?, aff_history=aff_history+? WHERE id=2",
        (REWARD, REWARD),
    )
    con.execute("UPDATE users SET quota=quota+? WHERE id=3", (REWARD,))
    print("backfilled zhenjiang -> wanyan")
else:
    print("skip backfill", inviter, invitee)
con.commit()

#!/usr/bin/env python3
"""把 wanyan 待确认的邀请奖励全部划进可用余额。总收入 aff_history 不变。"""
import sqlite3

con = sqlite3.connect("/opt/new-api/data/one-api.db")
con.execute("BEGIN IMMEDIATE")
row = con.execute(
    "SELECT quota, aff_quota, aff_history, aff_count FROM users WHERE id=2 AND username='wanyan'"
).fetchone()
print("before", row)
if row is None or row[1] <= 0:
    con.rollback()
    raise SystemExit("没有待划转的邀请奖励")
con.execute(
    "UPDATE users SET quota = quota + aff_quota, aff_quota = 0 WHERE id=2 AND username='wanyan'"
)
con.commit()
print(
    "after",
    con.execute(
        "SELECT quota, aff_quota, aff_history, aff_count FROM users WHERE id=2"
    ).fetchone(),
)

--max-num-seqs 4
--max-model-len 8192
--max-num-batched-tokens 8192
--gpu-memory-utilization 0.80
--tensor-parallel-size 2
--enable-prefix-caching
--served-model-name qwen3.6-27b
--host 0.0.0.0
--port 8000