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

在大模型应用快速普及的今天，很多团队都会遇到同一个问题：模型效果不错，但成本越来越高。尤其当业务从 Demo 进入真实生产环境后，请求量、上下文长度、并发量都会迅速上升，推理费用、服务器费用、带宽费用和运维成本也会随之增加。

DeepSeek 的出现，让不少开发者和企业看到了降低 AI 成本的可能。一方面，DeepSeek 系列模型在代码、推理、中文理解等方面具备较强能力；另一方面，它支持 API 调用，也可以通过开源模型进行本地化部署。只要方法得当，DeepSeek 可以显著降低大模型应用的整体使用成本。

本文将从 API 使用、本地部署、模型选择、缓存、上下文控制、量化、路由策略、工程优化 等方面，系统讲解 DeepSeek 如何降低成本，并附上可直接使用的完整命令。

一、为什么 DeepSeek 能降低成本？

DeepSeek 降低成本主要体现在以下几个方面：

1. 模型性价比高
   DeepSeek 在不少任务上表现接近甚至达到一线闭源模型水平，但使用成本通常更低。

2. 支持开源部署
   对于有一定技术能力的团队，可以选择部署 DeepSeek 开源模型，避免长期高额 API 调用成本。

3. 适合中文和代码场景
   如果业务主要是中文客服、知识库问答、代码生成、数据分析等，DeepSeek 往往能以较低成本获得较好效果。

4. 可以灵活选择不同模型规格
   并非所有任务都需要最大模型。简单分类、摘要、改写、问答等任务可以使用较小模型，从而降低推理成本。

5. 容易与缓存、路由、RAG 等方案结合
   在工程上做一些优化后，可以大幅减少重复请求和无效 Token 消耗。

二、第一种方式：直接使用 DeepSeek API 降低成本

如果你不想自己购买服务器、配置 GPU、维护推理服务，那么使用 DeepSeek API 是最简单的方式。

1. 准备 API Key

你需要先在 DeepSeek 官网申请 API Key。拿到 Key 后，建议通过环境变量配置，不要直接写入代码。

Linux / macOS 命令如下：

export DEEPSEEK_API_KEY="你的DeepSeek_API_Key"

Windows PowerShell 命令如下：

$env:DEEPSEEK_API_KEY="你的DeepSeek_API_Key"

如果你希望长期生效，可以写入 shell 配置文件。

macOS / Linux：

echo 'export DEEPSEEK_API_KEY="你的DeepSeek_API_Key"' >> ~/.bashrc
source ~/.bashrc

如果你使用的是 zsh：

echo 'export DEEPSEEK_API_KEY="你的DeepSeek_API_Key"' >> ~/.zshrc
source ~/.zshrc

2. 使用 curl 调用 DeepSeek API

下面是一个最基础的调用示例：

curl https://api.deepseek.com/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-chat",
    "messages": [
      {
        "role": "system",
        "content": "你是一个专业、简洁的中文助手。"
      },
      {
        "role": "user",
        "content": "请用三句话解释什么是大模型。"
      }
    ],
    "temperature": 0.7,
    "max_tokens": 300
  }'

这个命令的关键点是：

• model：选择模型；
• messages：对话内容；
• max_tokens：限制最大输出长度；
• temperature：控制随机性。

降低成本时，最重要的参数之一就是 max_tokens。不要让模型无限输出，尤其是在摘要、分类、提取字段等任务中，应严格限制输出长度。

3. 使用 Python 调用 DeepSeek API

安装依赖：

pip install openai

Python 示例代码：

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {"role": "system", "content": "你是一个专业、简洁的中文助手。"},
        {"role": "user", "content": "请总结一下使用 DeepSeek 降低成本的方法。"}
    ],
    temperature=0.5,
    max_tokens=500
)

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

运行命令：

python deepseek_demo.py

三、控制 Token：最直接的降本手段

大模型计费通常与 Token 数量有关。Token 可以理解为模型处理文本的基本单位。输入越长、输出越长，成本越高。

因此，降低成本的第一原则是：

减少不必要的输入，限制不必要的输出。

1. 精简 Prompt

很多人写 Prompt 时喜欢加入大量说明，例如：

你是一个非常聪明、非常专业、非常有经验、非常严谨、非常友好的助手……

这类描述如果每次请求都重复出现，会带来持续的 Token 消耗。可以改成更简洁的版本：

你是专业中文助手，回答简洁准确。

如果系统提示词非常长，可以考虑：

• 只保留关键规则；
• 将固定知识放入知识库；
• 使用 RAG 检索相关内容；
• 对长文档先摘要再提问。

2. 限制输出长度

比如让模型返回 JSON，不要输出解释：

{
  "category": "售后",
  "priority": "高",
  "summary": "用户反馈订单未收到"
}

API 调用示例：

curl https://api.deepseek.com/chat/completions \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-chat",
    "messages": [
      {
        "role": "system",
        "content": "你是文本分类器，只返回JSON，不要解释。"
      },
      {
        "role": "user",
        "content": "用户说：我买的耳机三天了还没收到，快递也查不到。"
      }
    ],
    "temperature": 0,
    "max_tokens": 100
  }'

这里通过 max_tokens: 100 限制输出长度，并要求只返回 JSON，可以明显减少输出 Token。

四、使用缓存：避免重复调用模型

很多 AI 应用存在大量重复请求，例如：

• 用户经常问相同问题；
• 系统重复处理相同文档；
• 多个用户查询同一知识点；
• 分类、摘要、标签生成任务重复执行。

这些场景非常适合加入缓存。

1. 安装 Redis

Ubuntu 安装 Redis：

sudo apt update
sudo apt install -y redis-server
sudo systemctl enable redis-server
sudo systemctl start redis-server

检查 Redis 状态：

redis-cli ping

如果返回：

PONG

说明 Redis 正常运行。

2. Python 中使用 Redis 缓存 DeepSeek 响应

安装依赖：

pip install openai redis

示例代码：

from openai import OpenAI
import redis
import hashlib
import json
import os

client = OpenAI(
    api_key=os.getenv("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)

r = redis.Redis(host="localhost", port=6379, db=0, decode_responses=True)

def cache_key(model, messages):
    raw = json.dumps({
        "model": model,
        "messages": messages
    }, ensure_ascii=False, sort_keys=True)
    return "deepseek:" + hashlib.sha256(raw.encode("utf-8")).hexdigest()

def ask_deepseek(messages, model="deepseek-chat"):
    key = cache_key(model, messages)
    cached = r.get(key)

    if cached:
        print("命中缓存")
        return cached

    print("调用 DeepSeek API")
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=0.3,
        max_tokens=500
    )

    answer = response.choices[0].message.content
    r.setex(key, 3600 * 24, answer)
    return answer

messages = [
    {"role": "system", "content": "你是专业中文助手，回答简洁准确。"},
    {"role": "user", "content": "DeepSeek 如何降低企业 AI 成本？"}
]

print(ask_deepseek(messages))

运行：

python deepseek_cache.py

缓存策略可以让重复问题直接返回结果，不再调用模型。对于 FAQ、客服、知识库问答等业务，缓存能带来非常明显的降本效果。

五、使用 RAG：不要把所有资料都塞进 Prompt

很多人在做知识库问答时，会把整篇文档、整本手册甚至大量历史记录都放进 Prompt。这样做不仅成本高，还会影响模型效果。

更好的方式是使用 RAG，即检索增强生成。简单来说：

1. 先把文档切块；
2. 将文档块向量化；
3. 用户提问时检索相关片段；
4. 只把相关片段发给 DeepSeek；
5. 模型基于相关内容回答。

这样可以显著减少输入 Token。

1. 安装依赖

pip install langchain langchain-community faiss-cpu sentence-transformers openai

2. 构建本地向量库

下面使用 sentence-transformers 和 FAISS 做一个简化版示例。

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np

docs = [
    "DeepSeek 可以通过 API 调用降低大模型使用门槛。",
    "对于高并发场景，可以通过本地部署 DeepSeek 开源模型降低长期成本。",
    "控制 Token 数量是降低大模型成本的重要方法。",
    "缓存可以避免重复请求，从而减少 API 调用费用。",
    "RAG 可以减少输入上下文长度，提高知识库问答效率。"
]

model = SentenceTransformer("BAAI/bge-small-zh-v1.5")
embeddings = model.encode(docs)

dimension = embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(np.array(embeddings).astype("float32"))

query = "如何减少 DeepSeek 的调用费用？"
query_embedding = model.encode([query]).astype("float32")

distances, indices = index.search(query_embedding, 3)

for i in indices[0]:
    print(docs[i])

运行：

python rag_demo.py

六、本地部署 DeepSeek：适合高调用量场景

如果你的调用量非常大，长期使用 API 可能成本较高。这时可以考虑本地部署开源模型。

本地部署的成本主要包括：

• GPU 服务器费用；
• 电费或云服务器费用；
• 运维成本；
• 模型加载与推理框架调优成本。

如果你的业务调用量不高，API 更划算；如果调用量很高，且请求稳定，本地部署可能更省钱。

七、使用 Ollama 快速部署 DeepSeek

Ollama 是一种非常适合开发者快速运行本地大模型的工具。它安装简单，适合个人开发、内部工具、小规模应用。

1. 安装 Ollama

Linux 安装：

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

macOS 可以使用 Homebrew：

brew install ollama

启动 Ollama：

ollama serve

2. 拉取 DeepSeek 模型

例如拉取 DeepSeek R1 蒸馏模型：

ollama pull deepseek-r1:7b

或者使用更小模型：

ollama pull deepseek-r1:1.5b

查看本地模型：

ollama list

运行模型：

ollama run deepseek-r1:7b

3. 使用 curl 调用本地 Ollama

curl http://localhost:11434/api/chat \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:7b",
    "messages": [
      {
        "role": "user",
        "content": "请解释 DeepSeek 本地部署为什么能降低成本。"
      }
    ],
    "stream": false
  }'

使用 Ollama 的好处是部署极其简单，适合快速验证。但如果是生产环境高并发服务，通常还需要考虑 vLLM、TensorRT-LLM 等更高性能的推理框架。

八、使用 vLLM 部署 DeepSeek，提高吞吐量

vLLM 是常见的大模型推理框架，适合高并发 API 服务。它支持连续批处理、PagedAttention 等优化技术，可以显著提高吞吐量。

1. 创建 Python 环境

conda create -n deepseek-vllm python=3.10 -y
conda activate deepseek-vllm

如果没有 conda，也可以使用 venv：

python3 -m venv deepseek-vllm
source deepseek-vllm/bin/activate

2. 安装 vLLM

pip install vllm

检查安装：

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

3. 启动 OpenAI 兼容 API 服务

以某个 Hugging Face 上的 DeepSeek 蒸馏模型为例：

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --max-model-len 8192 \
  --gpu-memory-utilization 0.90

如果你希望限制上下文长度进一步节省显存，可以改成：

vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
  --host 0.0.0.0 \
  --port 8000 \
  --dtype auto \
  --max-model-len 4096 \
  --gpu-memory-utilization 0.90

4. 调用本地 vLLM 服务

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 如何帮助 DeepSeek 降低推理成本。"
      }
    ],
    "temperature": 0.5,
    "max_tokens": 500
  }'

vLLM 的优势在于：当请求量上来后，它可以更充分地利用 GPU，减少单位请求成本。

九、通过模型分级路由降低成本

并不是每个任务都需要强模型。一个成熟的 AI 系统通常会设计模型路由策略：

• 简单任务：小模型处理；
• 中等任务：普通模型处理；
• 复杂推理：强模型处理；
• 高价值任务：使用最强模型；
• 低价值任务：限制输出或拒绝复杂生成。

例如：

下面是一个简单路由示例：

def choose_model(user_input):
    if len(user_input) < 50 and any(x in user_input for x in ["分类", "标签", "情绪"]):
        return "small-model"
    elif any(x in user_input for x in ["推理", "证明", "复杂", "代码"]):
        return "deepseek-reasoner"
    else:
        return "deepseek-chat"

在实际业务中，你可以结合：

• 请求长度；
• 用户等级；
• 任务类型；
• 历史命中率；
• 是否需要推理；
• 是否有知识库答案；

来决定使用哪个模型。

十、量化部署：用更低显存运行模型

如果选择本地部署，GPU 显存是核心成本之一。量化可以把模型权重从 FP16 降到 INT8、INT4，从而减少显存占用。

常见量化方式包括：

• 8-bit 量化；
• 4-bit 量化；
• GPTQ；
• AWQ；
• GGUF。

量化的优点是显存占用更低、部署成本更低；缺点是可能有一定效果损失。

使用 llama.cpp 运行 GGUF 模型

安装编译工具：

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

克隆 llama.cpp：

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

编译：

cmake -B build
cmake --build build --config Release

如果你有 NVIDIA GPU，可以尝试 CUDA 编译：

cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release

运行 GGUF 模型：

./build/bin/llama-cli \
  -m /path/to/deepseek-model.gguf \
  -p "请用中文解释量化如何降低 DeepSeek 部署成本。" \
  -n 512

启动 HTTP 服务：

./build/bin/llama-server \
  -m /path/to/deepseek-model.gguf \
  --host 0.0.0.0 \
  --port 8080 \
  -c 4096

调用服务：

curl http://localhost:8080/completion \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "请说明 GGUF 量化模型适合哪些低成本场景。",
    "n_predict": 300
  }'

十一、日志监控：知道钱花在哪里

想降低成本，必须先知道成本花在哪里。建议记录以下指标：

• 每次请求输入 Token；
• 每次请求输出 Token；
• 请求耗时；
• 用户 ID；
• 任务类型；
• 模型名称；
• 是否命中缓存；
• 是否使用 RAG；
• 请求成功率；
• 单次请求成本估算。

一个简单的日志结构如下：

{
  "user_id": "u_10001",
  "model": "deepseek-chat",
  "task_type": "faq",
  "prompt_tokens": 820,
  "completion_tokens": 180,
  "cache_hit": false,
  "latency_ms": 1320,
  "created_at": "2025-01-01T10:00:00"
}

只有数据足够清楚，才能找到真正浪费成本的地方。例如，你可能会发现：

• 80% 的请求来自重复问题；
• 某些 Prompt 太长；
• 某些接口没有限制 max_tokens；
• 部分用户滥用长文本生成；
• RAG 检索返回了太多无关片段。

十二、生产环境中的综合降本方案

如果要在生产环境中使用 DeepSeek，推荐采用如下架构：

用户请求
  ↓
网关鉴权与限流
  ↓
缓存查询 Redis
  ↓
任务分类与模型路由
  ↓
RAG 检索相关知识
  ↓
调用 DeepSeek API 或本地模型
  ↓
结果后处理
  ↓
写入缓存与日志
  ↓
返回用户

这个流程的核心思想是：

1. 能不调用模型，就不调用模型；
2. 能用小模型，就不用大模型；
3. 能少输入，就不多输入；
4. 能少输出，就不长篇输出；
5. 能缓存，就缓存；
6. 能批处理，就批处理；
7. 能本地部署且调用量足够大，就本地部署。

十三、常见降本误区

误区一：只看模型单价

模型单价低不代表总成本低。还要看：

• 生成长度；
• 成功率；
• 重试率；
• 响应速度；
• 是否需要人工修正；
• 是否需要多轮调用。

如果一个便宜模型经常答错，导致多次重试，最终成本可能更高。

误区二：盲目本地部署

本地部署并不是一定省钱。你需要考虑 GPU 成本、机器闲置率、运维人员成本和稳定性。如果调用量不高，API 往往更划算。

误区三：上下文越长越好

很多业务把大量无关内容塞进上下文，结果不仅成本高，效果还变差。RAG 检索、摘要压缩、上下文裁剪往往比“全量塞入”更有效。

误区四：所有任务都用最强模型

很多分类、提取、改写任务，用小模型或规则即可完成。最强模型应该留给复杂推理、代码生成、关键决策等高价值任务。

十四、推荐的落地步骤

如果你正在从零开始使用 DeepSeek，建议按照以下顺序落地：

1. 先用 API 快速验证效果
   不要一开始就部署复杂基础设施。

2. 记录 Token 和请求日志
   找出成本主要来源。

3. 优化 Prompt 和 max_tokens
   这是最简单、最快见效的方法。

4. 增加缓存
   对重复问题、固定任务进行缓存。

5. 引入 RAG
   减少长文档输入，提高知识库问答效率。

6. 建立模型路由
   简单任务走小模型，复杂任务走强模型。

7. 评估本地部署
   当调用量足够大时，再考虑 vLLM、Ollama、llama.cpp 等方案。

8. 持续压测和监控
   用数据验证每项优化是否真正省钱。

十五、总结

DeepSeek 降低成本并不是单靠“模型便宜”实现的，而是通过模型能力、开源部署和工程优化共同完成的。

最有效的降本方法包括：

• 使用 DeepSeek API 快速获得高性价比能力；
• 控制输入和输出 Token；
• 设置合理的 max_tokens；
• 使用缓存减少重复调用；
• 通过 RAG 避免长上下文浪费；
• 使用模型分级路由，让不同任务匹配不同模型；
• 对高调用量业务采用本地部署；
• 通过量化降低显存需求；
• 使用 vLLM 提高 GPU 吞吐；
• 建立日志监控体系，持续发现成本浪费点。

一句话概括：

DeepSeek 真正的降本价值，不只是模型价格低，而是它让企业可以在 API、本地部署、开源模型和工程优化之间灵活选择，从而构建更经济的大模型应用。

如果你的业务刚起步，建议先使用 DeepSeek API；如果业务调用量稳定且较大，可以逐步引入缓存、RAG、模型路由和本地部署。这样既能保证效果，又能把成本控制在合理范围内。