DeepSeek 如何降低成本｜附完整命令

DeepSeek 之所以被频繁讨论，不仅因为它在推理、代码、数学等任务上表现突出，更重要的是：它把“大模型能力”与“成本控制”这两个过去看似矛盾的目标，放到了同一个方案里。

对于企业或个人开发者来说，使用大模型的成本主要来自三部分：

1. 调用成本：通过 API 调用模型时，按照 Token 收费。
2. 部署成本：自建模型服务时，需要 GPU、服务器、存储和运维。
3. 使用成本：Prompt 设计不当、重复请求、上下文过长、模型选择错误，都会造成浪费。

本文将从工程实践角度，系统讲解如何使用 DeepSeek 降低成本，并提供一套可直接执行的完整命令，包括 API 调用、本地部署、量化运行、vLLM 推理服务、Ollama 快速运行、缓存与批处理优化等方案。

一、DeepSeek 降低成本的核心思路

要降低 DeepSeek 使用成本，不能只看“模型单价”，而要看整体链路。

一个完整的大模型应用通常包含：

用户输入
  ↓
Prompt 构造
  ↓
模型调用 / 本地推理
  ↓
结果解析
  ↓
业务处理
  ↓
返回用户

每个环节都有优化空间。

常见的降本方向包括：

二、优先选择合适的 DeepSeek 模型

DeepSeek 系列模型通常包括不同规模、不同用途的版本，例如通用对话模型、推理模型、代码模型、蒸馏模型等。

在实际业务中，最常见的浪费是：所有任务都调用最强模型。

例如：

• 用户只是问一个简单 FAQ，却调用大推理模型；
• 只需要摘要，却使用长链路推理；
• 只需要分类，却生成大段文本；
• 明明可以用规则解决，却每次请求大模型。

更合理的策略是分层调用。

推荐模型分层策略

简单任务：
  分类、标签、改写、简单摘要
  ↓
  使用小模型或蒸馏模型

中等任务：
  问答、代码解释、结构化输出
  ↓
  使用通用对话模型

复杂任务：
  数学、代码生成、复杂推理、规划
  ↓
  使用 DeepSeek 推理模型

高频重复任务：
  FAQ、固定文案、标准流程
  ↓
  使用缓存或规则系统

这样做的收益非常明显：
不是每个问题都值得用最强模型。

三、通过 API 调用 DeepSeek：最简单的低成本方案

如果你的请求量不大，或者团队没有 GPU 运维能力，优先使用 API 通常更划算。

API 的优点是：

• 不需要买 GPU；
• 不需要维护推理服务；
• 可以快速上线；
• 按量付费，适合早期项目。

下面以兼容 OpenAI API 风格的调用方式为例。

注意：实际 base URL、模型名称、API Key 请以你使用的平台为准。

四、准备环境

1. 安装 Python 环境

python3 --version

如果没有 Python，可以安装：

sudo apt update
sudo apt install -y python3 python3-pip python3-venv

创建项目目录：

mkdir deepseek-cost-demo
cd deepseek-cost-demo

创建虚拟环境：

python3 -m venv .venv
source .venv/bin/activate

安装依赖：

pip install openai python-dotenv

五、配置 API Key

创建 .env 文件：

cat > .env << 'EOF'
DEEPSEEK_API_KEY=你的_API_KEY
DEEPSEEK_BASE_URL=https://api.deepseek.com
EOF

创建 Python 调用脚本：

cat > call_deepseek.py << 'EOF'
import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL")
)

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {
            "role": "system",
            "content": "你是一个高效、简洁、准确的中文助手。"
        },
        {
            "role": "user",
            "content": "请用三句话解释什么是大模型推理成本。"
        }
    ],
    temperature=0.3,
    max_tokens=300
)

print(response.choices[0].message.content)
EOF

执行：

python call_deepseek.py

六、API 降本关键：限制 max_tokens

很多人调用大模型时不设置 max_tokens，导致模型输出过长，成本失控。

例如你只是做一个分类任务，理论上只需要输出一个标签，却让模型生成几百字解释，这就是浪费。

错误示例

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "user", "content": "判断这句话情绪是正面还是负面：这个产品太差了"}
    ]
)

正确示例

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {
            "role": "system",
            "content": "你是文本分类器，只能输出：正面、负面、中性。不要解释。"
        },
        {
            "role": "user",
            "content": "判断这句话情绪：这个产品太差了"
        }
    ],
    temperature=0,
    max_tokens=10
)

创建完整脚本：

cat > classify.py << 'EOF'
import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL")
)

text = "这个产品太差了，完全不值这个价格。"

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {
            "role": "system",
            "content": "你是文本情绪分类器。只能输出：正面、负面、中性。不要解释。"
        },
        {
            "role": "user",
            "content": f"请判断下面文本的情绪：{text}"
        }
    ],
    temperature=0,
    max_tokens=10
)

print(response.choices[0].message.content)
EOF

python classify.py

七、用 Prompt 压缩降低输入成本

Token 成本不仅来自输出，也来自输入。很多团队会把大量无关资料塞进 Prompt，导致每次请求都非常贵。

例如：

请阅读以下 5 万字文档，然后回答用户问题。

这是非常典型的高成本写法。

更好的方式是：

1. 先做文档切片；
2. 用向量检索找出相关片段；
3. 只把相关片段交给模型；
4. 控制上下文长度。

这就是 RAG，也就是检索增强生成。

简单 Prompt 压缩原则

• 删除无关背景；
• 删除重复规则；
• 把长说明改成结构化要求；
• 让模型只输出必要内容；
• 使用 JSON 格式减少废话；
• 对固定系统提示词进行版本管理。

例如：

原始 Prompt

你是一个非常优秀、经验丰富、能力很强、认真负责的客服专家。
你需要站在用户角度思考问题，耐心回答用户。
请你根据下面提供的一大段知识库内容回答用户问题。
如果不知道也不要乱说。
请尽量专业、准确、友好。
用户问题是：如何申请退款？
知识库内容如下：……

优化后 Prompt

角色：客服助手。
规则：
1. 仅根据知识库回答；
2. 不知道则回答“暂未查询到相关信息”；
3. 输出不超过 150 字。

问题：如何申请退款？
知识库：……

输入 Token 通常可以减少 30% 到 70%。

八、本地部署 DeepSeek：适合高频调用场景

如果你的业务每天调用量很高，或者需要私有化部署，那么可以考虑本地运行 DeepSeek 蒸馏模型或量化模型。

本地部署的成本优势是：

• 高频调用时边际成本低；
• 数据不出内网；
• 可控性强；
• 可以结合缓存、批处理进一步优化。

缺点是：

• 需要 GPU 或较强 CPU；
• 需要运维能力；
• 模型越大，对显存要求越高。

九、使用 Ollama 快速运行 DeepSeek

Ollama 是最简单的本地模型运行方式之一，适合个人开发者、测试环境、小规模服务。

1. 安装 Ollama

Linux/macOS 可以执行：

curl -fsSL https://ollama.com/install.sh | sh

查看版本：

ollama --version

启动服务：

ollama serve

如果服务已经自动启动，可以忽略。

2. 拉取 DeepSeek 模型

例如拉取 DeepSeek R1 蒸馏模型：

ollama pull deepseek-r1:7b

如果机器性能较弱，可以选择更小模型：

ollama pull deepseek-r1:1.5b

如果显存较大，可以使用更大模型：

ollama pull deepseek-r1:14b

查看已安装模型：

ollama list

3. 命令行运行

ollama run deepseek-r1:7b

输入问题：

请解释如何降低大模型 API 调用成本。

4. 使用 Ollama API 调用

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:7b",
    "prompt": "请用五点说明 DeepSeek 如何降低企业 AI 应用成本。",
    "stream": false
  }'

5. Python 调用 Ollama

安装 requests：

pip install requests

创建脚本：

cat > ollama_deepseek.py << 'EOF'
import requests

url = "http://localhost:11434/api/generate"

payload = {
    "model": "deepseek-r1:7b",
    "prompt": "请用三点说明本地部署大模型的成本优势。",
    "stream": False,
    "options": {
        "temperature": 0.3,
        "num_predict": 300
    }
}

response = requests.post(url, json=payload)
print(response.json()["response"])
EOF

python ollama_deepseek.py

十、使用 vLLM 部署 DeepSeek：适合生产推理服务

如果你希望搭建生产级推理服务，vLLM 是常见选择。它的优势是：

• 支持高吞吐推理；
• 支持连续批处理；
• 支持 OpenAI API 格式；
• GPU 利用率更高；
• 适合多用户并发。

十一、安装 NVIDIA 驱动与 CUDA 检查

先检查 GPU：

nvidia-smi

如果没有输出，说明驱动未安装或 GPU 不可用。

安装基础工具：

sudo apt update
sudo apt install -y git git-lfs curl wget python3 python3-pip python3-venv

创建环境：

mkdir deepseek-vllm
cd deepseek-vllm

python3 -m venv .venv
source .venv/bin/activate

pip install --upgrade pip

安装 vLLM：

pip install vllm

检查安装：

python -c "import vllm; print(vllm.__version__)"

十二、启动 DeepSeek vLLM 服务

以 Hugging Face 模型为例，假设使用 DeepSeek-R1-Distill-Qwen-7B：

export MODEL_NAME=deepseek-ai/DeepSeek-R1-Distill-Qwen-7B

启动 OpenAI 兼容 API 服务：

python -m vllm.entrypoints.openai.api_server \
  --model $MODEL_NAME \
  --host 0.0.0.0 \
  --port 8000 \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.90 \
  --dtype auto

如果显存不足，可以降低上下文长度：

python -m vllm.entrypoints.openai.api_server \
  --model $MODEL_NAME \
  --host 0.0.0.0 \
  --port 8000 \
  --max-model-len 4096 \
  --gpu-memory-utilization 0.85 \
  --dtype auto

十三、测试 vLLM 服务

使用 curl：

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
    "messages": [
      {
        "role": "system",
        "content": "你是一个简洁的中文助手。"
      },
      {
        "role": "user",
        "content": "请说明 vLLM 为什么可以降低推理成本。"
      }
    ],
    "temperature": 0.3,
    "max_tokens": 300
  }'

使用 Python：

cat > test_vllm.py << 'EOF'
from openai import OpenAI

client = OpenAI(
    api_key="EMPTY",
    base_url="http://localhost:8000/v1"
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
    messages=[
        {"role": "system", "content": "你是一个简洁的中文助手。"},
        {"role": "user", "content": "请用三点说明 vLLM 如何降低大模型服务成本。"}
    ],
    temperature=0.3,
    max_tokens=300
)

print(response.choices[0].message.content)
EOF

python test_vllm.py

十四、通过量化进一步降低成本

量化的本质是降低模型权重精度，例如从 FP16 降到 INT8、INT4，从而减少显存占用。

量化的好处：

• 更小显存即可运行；
• 可以使用更便宜的 GPU；
• 推理速度可能提升；
• 本地部署门槛降低。

量化的代价：

• 输出质量可能略有下降；
• 某些任务准确率可能受影响；
• 不同量化格式兼容性不同。

对于成本敏感场景，可以优先考虑 4-bit 或 8-bit 量化模型。

十五、使用 llama.cpp 运行 GGUF 量化模型

llama.cpp 适合 CPU 或轻量 GPU 环境，常用于运行 GGUF 格式模型。

1. 安装依赖

sudo apt update
sudo apt install -y git cmake build-essential curl

2. 下载 llama.cpp

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

3. 编译

CPU 编译：

cmake -B build
cmake --build build -j

如果使用 NVIDIA GPU，可以尝试 CUDA 编译：

cmake -B build -DGGML_CUDA=ON
cmake --build build -j

4. 下载 GGUF 模型

安装 Hugging Face CLI：

pip install -U huggingface_hub

创建模型目录：

mkdir -p models

下载模型时，请选择与你机器匹配的 GGUF 量化版本。示例命令如下：

huggingface-cli download \
  bartowski/DeepSeek-R1-Distill-Qwen-7B-GGUF \
  DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf \
  --local-dir models \
  --local-dir-use-symlinks False

如果该仓库或文件名发生变化，请在 Hugging Face 页面确认最新名称。

5. 命令行推理

./build/bin/llama-cli \
  -m models/DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf \
  -p "请用五点说明量化模型如何降低部署成本。" \
  -n 512 \
  -t 8 \
  -c 4096

参数说明：

如果你有 GPU，可以指定 GPU offload 层数：

./build/bin/llama-cli \
  -m models/DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf \
  -p "请解释本地量化部署的优缺点。" \
  -n 512 \
  -t 8 \
  -c 4096 \
  -ngl 35

十六、搭建 llama.cpp HTTP 服务

启动服务：

./build/bin/llama-server \
  -m models/DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf \
  --host 0.0.0.0 \
  --port 8080 \
  -c 4096 \
  -ngl 35

调用接口：

curl http://localhost:8080/completion \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "请用三点说明 llama.cpp 适合哪些低成本场景。",
    "n_predict": 300,
    "temperature": 0.3
  }'

十七、使用缓存减少重复调用

很多业务里，用户会反复问类似问题。例如：

• “怎么退款？”
• “退款流程是什么？”
• “我想退货怎么操作？”
• “申请退款多久到账？”

如果每次都调用 DeepSeek，成本会持续增加。
更好的方式是先做缓存命中。

简单缓存示例

创建脚本：

cat > cached_call.py << 'EOF'
import os
import hashlib
import sqlite3
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

DB_PATH = "cache.db"

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL")
)

def init_db():
    conn = sqlite3.connect(DB_PATH)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS cache (
            key TEXT PRIMARY KEY,
            prompt TEXT,
            answer TEXT
        )
    """)
    conn.commit()
    conn.close()

def cache_key(text):
    return hashlib.sha256(text.strip().encode("utf-8")).hexdigest()

def get_cache(key):
    conn = sqlite3.connect(DB_PATH)
    row = conn.execute("SELECT answer FROM cache WHERE key=?", (key,)).fetchone()
    conn.close()
    return row[0] if row else None

def set_cache(key, prompt, answer):
    conn = sqlite3.connect(DB_PATH)
    conn.execute(
        "INSERT OR REPLACE INTO cache(key, prompt, answer) VALUES (?, ?, ?)",
        (key, prompt, answer)
    )
    conn.commit()
    conn.close()

def ask(prompt):
    key = cache_key(prompt)
    cached = get_cache(key)
    if cached:
        print("[CACHE HIT]")
        return cached

    print("[MODEL CALL]")
    response = client.chat.completions.create(
        model="deepseek-chat",
        messages=[
            {"role": "system", "content": "你是一个简洁准确的中文助手。"},
            {"role": "user", "content": prompt}
        ],
        temperature=0.2,
        max_tokens=300
    )

    answer = response.choices[0].message.content
    set_cache(key, prompt, answer)
    return answer

if __name__ == "__main__":
    init_db()
    question = "请说明如何降低大模型 API 调用成本。"
    print(ask(question))
    print(ask(question))
EOF

python cached_call.py

第二次调用时就会命中缓存，不再请求模型。

十八、批处理：提高吞吐，摊薄 GPU 成本

如果你是自建服务，GPU 最大浪费往往不是“模型太大”，而是“GPU 空转”。

例如每次只处理一个请求，GPU 利用率可能很低。vLLM 的连续批处理可以自动合并多个请求，从而提升吞吐。

对于离线任务，例如批量摘要、批量分类、批量生成标题，可以把多个任务合并执行。

批量分类示例

cat > batch_classify.py << 'EOF'
import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL")
)

texts = [
    "这个产品很好用，下次还会买。",
    "客服太慢了，体验很差。",
    "物流今天到了，还没开始用。",
    "价格实惠，质量不错。"
]

prompt = """
你是文本情绪分类器。
请对每条文本分类，只能输出 JSON 数组。
标签只能是：正面、负面、中性。

文本列表：
""" + "\n".join([f"{i+1}. {t}" for i, t in enumerate(texts)])

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "你只输出 JSON，不要解释。"},
        {"role": "user", "content": prompt}
    ],
    temperature=0,
    max_tokens=200
)

print(response.choices[0].message.content)
EOF

python batch_classify.py

相比逐条调用，批处理可以减少请求次数和重复系统提示词 Token。

十九、模型路由：让便宜模型先处理

一个成熟的大模型系统不应该只有一个模型，而应该有路由策略。

例如：

用户请求
  ↓
规则判断 / 小模型分类
  ↓
简单问题 → 小模型
复杂问题 → DeepSeek 强模型
敏感问题 → 专门安全模型
知识库问题 → RAG
重复问题 → 缓存

简单模型路由示例

cat > router.py << 'EOF'
def route_task(user_input: str):
    simple_keywords = ["总结", "改写", "翻译", "分类", "提取"]
    complex_keywords = ["推理", "证明", "算法", "代码", "数学", "规划"]

    if len(user_input) < 50 and any(k in user_input for k in simple_keywords):
        return "cheap_model"

    if any(k in user_input for k in complex_keywords):
        return "deepseek_reasoner"

    return "deepseek_chat"

tests = [
    "请把这句话改写得更正式。",
    "请证明这个数学结论是否成立。",
    "请帮我写一个 Python 爬虫。",
    "今天北京天气怎么样？"
]

for t in tests:
    print(t, "=>", route_task(t))
EOF

python router.py

生产环境中可以把路由做得更复杂，例如结合：

• Prompt 长度；
• 用户等级；
• 任务类型；
• 历史命中率；
• 延迟要求；
• 预算上限。

二十、控制上下文长度，避免“越聊越贵”

聊天机器人常见问题是上下文无限累积。

如果每轮对话都携带完整历史，Token 会越来越多，成本也会越来越高。

优化策略

1. 只保留最近几轮对话；
2. 对历史对话做摘要；
3. 对长期记忆单独存储；
4. 用户问题与历史无关时不携带历史；
5. 使用 RAG 检索相关记忆。

简单历史截断示例

cat > history_trim.py << 'EOF'
def trim_history(messages, keep_last=6):
    system_messages = [m for m in messages if m["role"] == "system"]
    other_messages = [m for m in messages if m["role"] != "system"]
    return system_messages + other_messages[-keep_last:]

messages = [
    {"role": "system", "content": "你是助手。"},
    {"role": "user", "content": "第一轮问题"},
    {"role": "assistant", "content": "第一轮回答"},
    {"role": "user", "content": "第二轮问题"},
    {"role": "assistant", "content": "第二轮回答"},
    {"role": "user", "content": "第三轮问题"},
    {"role": "assistant", "content": "第三轮回答"},
    {"role": "user", "content": "第四轮问题"}
]

trimmed = trim_history(messages, keep_last=4)

for m in trimmed:
    print(m)
EOF

python history_trim.py

二十一、输出结构化结果，减少废话 Token

很多业务并不需要自然语言长回答，只需要结构化结果。

例如：

• 分类；
• 评分；
• 是否通过；
• 提取字段；
• SQL 生成；
• JSON 数据。

让模型输出 JSON，可以减少无效解释，也方便程序解析。

示例

cat > json_extract.py << 'EOF'
import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL")
)

text = "张三，手机号 13800138000，想预约明天下午三点的体检。"

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {
            "role": "system",
            "content": "你是信息抽取器，只输出 JSON，不要解释。"
        },
        {
            "role": "user",
            "content": f"""
请从文本中抽取姓名、手机号、预约事项、预约时间。

文本：
{text}
"""
        }
    ],
    temperature=0,
    max_tokens=150
)

print(response.choices[0].message.content)
EOF

python json_extract.py

二十二、设置预算保护，防止成本失控

工程上必须设置成本保护机制，尤其是多用户系统。

建议至少加入：

• 单用户每日调用次数限制；
• 单用户每日 Token 限制；
• 单请求最大输入长度限制；
• 单请求最大输出长度限制；
• 异常请求熔断；
• 高成本模型调用审批；
• 日志统计与报警。

简单输入长度限制示例

cat > guard.py << 'EOF'
MAX_CHARS = 4000

def check_input(text):
    if len(text) > MAX_CHARS:
        raise ValueError(f"输入过长，当前 {len(text)} 字符，最大允许 {MAX_CHARS} 字符")
    return text

try:
    user_input = "请总结：" + "很长的文本" * 1000
    check_input(user_input)
    print("允许调用模型")
except ValueError as e:
    print("拒绝调用：", e)
EOF

python guard.py

二十三、推荐的低成本架构

对于大多数企业应用，可以采用以下架构：

用户请求
  ↓
输入校验
  ↓
缓存查询
  ↓
任务分类 / 模型路由
  ↓
是否需要知识库？
  ├─ 是：RAG 检索相关片段
  └─ 否：直接构造 Prompt
  ↓
选择模型
  ├─ 简单任务：小模型 / 本地模型
  ├─ 普通任务：DeepSeek Chat
  └─ 复杂任务：DeepSeek Reasoner
  ↓
限制 max_tokens
  ↓
返回结构化结果
  ↓
写入缓存与日志

这套架构的关键不是“只用便宜模型”，而是：
让每一次模型调用都物有所值。

二十四、完整一键示例：API + 缓存 + 限流 + Token 控制

下面给出一个更完整的可运行示例，适合做基础模板。

cat > app.py << 'EOF'
import os
import time
import hashlib
import sqlite3
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

DB_PATH = "app_cache.db"
MAX_INPUT_CHARS = 3000
MAX_TOKENS = 300
RATE_LIMIT_SECONDS = 2

last_call_time = {}

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url=os.getenv("DEEPSEEK_BASE_URL")
)

def init_db():
    conn = sqlite3.connect(DB_PATH)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS cache (
            key TEXT PRIMARY KEY,
            prompt TEXT,
            answer TEXT,
            created_at INTEGER
        )
    """)
    conn.commit()
    conn.close()

def make_key(text):
    normalized = text.strip()
    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()

def get_cache(key):
    conn = sqlite3.connect(DB_PATH)
    row = conn.execute("SELECT answer FROM cache WHERE key=?", (key,)).fetchone()
    conn.close()
    return row[0] if row else None

def set_cache(key, prompt, answer):
    conn = sqlite3.connect(DB_PATH)
    conn.execute(
        "INSERT OR REPLACE INTO cache(key, prompt, answer, created_at) VALUES (?, ?, ?, ?)",
        (key, prompt, answer, int(time.time()))
    )
    conn.commit()
    conn.close()

def check_rate_limit(user_id):
    now = time.time()
    last = last_call_time.get(user_id, 0)
    if now - last < RATE_LIMIT_SECONDS:
        raise Exception("请求过于频繁，请稍后再试")
    last_call_time[user_id] = now

def check_input(text):
    if not text.strip():
        raise Exception("输入不能为空")
    if len(text) > MAX_INPUT_CHARS:
        raise Exception(f"输入过长，最大允许 {MAX_INPUT_CHARS} 字符")
    return text.strip()

def route_model(prompt):
    complex_words = ["推理", "证明", "复杂", "算法", "数学", "代码"]
    if any(w in prompt for w in complex_words):
        return "deepseek-reasoner"
    return "deepseek-chat"

def ask(user_id, prompt):
    check_rate_limit(user_id)
    prompt = check_input(prompt)

    key = make_key(prompt)
    cached = get_cache(key)
    if cached:
        return {
            "source": "cache",
            "model": None,
            "answer": cached
        }

    model = route_model(prompt)

    response = client.chat.completions.create(
        model=model,
        messages=[
            {
                "role": "system",
                "content": "你是一个中文助手。回答要准确、简洁、结构清晰。"
            },
            {
                "role": "user",
                "content": prompt
            }
        ],
        temperature=0.3,
        max_tokens=MAX_TOKENS
    )

    answer = response.choices[0].message.content
    set_cache(key, prompt, answer)

    return {
        "source": "model",
        "model": model,
        "answer": answer
    }

if __name__ == "__main__":
    init_db()

    user_id = "user_001"
    prompt = "请用五点说明 DeepSeek 如何帮助企业降低 AI 应用成本。"

    result = ask(user_id, prompt)
    print(result)
EOF

python app.py

二十五、最终建议：先优化使用方式，再考虑换模型

很多团队一开始就问：“哪个模型最便宜？”
但更关键的问题应该是：“我的调用方式是否浪费？”

如果 Prompt 冗长、没有缓存、没有限流、没有模型路由、没有 max_tokens 控制，那么即使换成便宜模型，也会继续浪费。

推荐的优化顺序是：

1. 先统计成本：记录每个接口、每类任务、每个用户的调用量；
2. 控制输出长度：所有请求必须设置 max_tokens；
3. 压缩输入 Prompt：删除无关上下文；
4. 增加缓存：重复问题不重复调用；
5. 做模型路由：简单任务用小模型；
6. 高频场景本地部署：使用 Ollama、vLLM、llama.cpp；
7. 使用量化模型：降低显存与硬件成本；
8. 批处理离线任务：提高吞吐；
9. 建立预算保护：避免异常请求导致费用暴涨。

总结

DeepSeek 降低成本的关键不只是模型本身便宜，而是它给开发者提供了更多灵活选择：可以通过 API 快速接入，也可以通过本地部署实现私有化；可以使用强推理模型解决复杂问题，也可以使用蒸馏和量化模型处理高频任务。

真正有效的降本方案，通常是组合拳：

合理模型选择
+ Prompt 压缩
+ max_tokens 控制
+ 缓存
+ 批处理
+ RAG
+ 本地部署
+ 量化推理
+ 成本监控

如果你只是个人开发者，可以从 API、Ollama、缓存开始；
如果你是企业团队，可以进一步使用 vLLM、模型路由、RAG 和预算系统；
如果你的调用量非常高，则应重点评估本地部署和量化模型。

一句话总结：

DeepSeek 能不能真正降低成本，不只取决于模型价格，更取决于你是否把每一次 Token 都用在了真正有价值的地方。