RAG 成本结构拆解：嵌入 + 搜索 + LLM

结论先行 — RAG 管道有三个成本组件：嵌入（一次性，text-embedding-v4 约 $1.30/百万 chunk）、搜索（$0.001–0.02/次查询）、LLM 生成（$0.01–0.15/次回答）。大多数知识库场景下，RAG 每个问题花费 $0.02–0.05。长上下文模型在 ~50 页以下胜出，但在 ~200 页以上严重亏损。本文提供精确的规划计算。

三层成本结构

每个 RAG（检索增强生成）管道都有相同的基本成本结构：

每次回答总成本 = 嵌入（分摊） + 搜索 + LLM 生成

三层各有不同特征：

• 嵌入 — 主要是一次性成本，摊到所有查询上
• 搜索 — 每次查询，通常是最便宜的部分
• LLM 生成 — 每次查询，通常是最贵的部分

用 2026 年真实定价逐层拆解。

第一层：嵌入成本

嵌入将文档转化为向量以进行相似性搜索。主要是文档导入时的一次性成本，加上更新时的增量成本。

2026 定价一览

模型	供应方	每 1K token 价格	维度	备注
text-embedding-v4	阿里/SandBase	$0.0015	1024/2048	最新，高质量
text-embedding-3-large	OpenAI	$0.00013	3072	性价比最高
text-embedding-3-small	OpenAI	$0.00002	1536	预算选项
embed-v4	Cohere	$0.0001	1024	多语言好
Voyage-3-large	Voyage AI	$0.00018	1024	代码专长

100 万文档的嵌入成本计算

假设：

• 平均文档：500 词 ≈ 650 tokens
• 分块策略：512 tokens/chunk，64 token 重叠
• 平均每文档 chunks：1.5（考虑短文档）
• 总 chunks：1,500,000

用 text-embedding-v4（$0.0015/1K tokens）：
  总 tokens：1,500,000 chunks × 512 = 768,000,000 tokens
  成本：768,000 × $0.0015 = $1,152

用 text-embedding-3-large（$0.00013/1K tokens）：
  成本：768,000 × $0.00013 = $99.84

用 text-embedding-3-small（$0.00002/1K tokens）：
  成本：768,000 × $0.00002 = $15.36

摊销

嵌入是一次性成本（每文档版本）。如果知识库在下次全量重嵌入前被查询 100,000 次：

每查询摊销嵌入成本：
  text-embedding-v4：$1,152 / 100,000 = $0.01152
  text-embedding-3-large：$99.84 / 100,000 = $0.001
  text-embedding-3-small：$15.36 / 100,000 = $0.00015

大多数应用中，摊销嵌入成本可以忽略——不到一分钱。

重嵌入触发条件

需要重新嵌入的场景：

• 文档更新（仅重嵌入变更文档）
• 切换嵌入模型（全量重嵌入）
• 变更分块策略（全量重嵌入）
• 新增文档（仅嵌入新文档）

更新模式	月嵌入成本（100 万文档库）
静态（无更新）	$0
月更新 1%	~$12（text-embedding-v4）
月更新 10%	~$115
月全量刷新	~$1,152

第二层：搜索成本

搜索为查询找到相关 chunks。有两个子组件：查询嵌入和向量相似性搜索。

查询嵌入

每次查询需用与文档相同的模型嵌入：

每次搜索的查询嵌入成本：
  平均查询：20 tokens
  text-embedding-v4：20/1000 × $0.0015 = $0.00003
  text-embedding-3-large：20/1000 × $0.00013 = $0.0000026

单次查询级别上等于免费。

向量数据库成本

显著的搜索成本是向量数据库托管：

方案	月费（150 万向量，1024 维）	1 万次/天的单次成本
Pinecone (Starter)	$70/月	$0.00023
Pinecone (Standard)	$200/月	$0.00067
Weaviate Cloud	$150/月	$0.0005
Qdrant Cloud	$100/月	$0.00033
pgvector（自托管）	$50–100/月	$0.00017–0.00033
ChromaDB（自托管）	$30–80/月	$0.0001–0.00027

搜索 API 服务

或者使用处理 嵌入 + 向量搜索 的搜索 API：

SandBase 搜索 API（如 Cloudsway）：
  $0.001–0.02/次搜索查询
  包含：查询嵌入 + 检索 + 重排序
  无需管理基础设施

每次查询的搜索总成本

自管理（Pinecone Standard + text-embedding-3-large）：
  查询嵌入：$0.0000026
  向量搜索：$0.00067
  合计：~$0.0007/次

托管搜索 API：
  $0.001–0.02/次（一价全包）

第三层：LLM 生成成本

最贵且变化最大的部分。这是检索到的上下文连同用户问题一起发送给 LLM 的环节。

Token 算术

典型 RAG 提示包含：

• 系统提示：~200 tokens
• 检索上下文：5 chunks × 512 tokens = 2,560 tokens
• 用户问题：~50 tokens
• 输入总计：~2,810 tokens
• 生成回答：~300–500 tokens

LLM 定价对比（2026）

模型	输入 $/百万 tokens	输出 $/百万 tokens	每次 RAG 回答成本
GPT-4.1	$2.00	$8.00	$0.0096
GPT-4.1-mini	$0.40	$1.60	$0.0019
Claude Sonnet 5	$3.00	$15.00	$0.0159
Claude Haiku 4	$0.80	$4.00	$0.0042
Kimi K3	$1.50	$6.00	$0.0072
DeepSeek V4	$0.50	$2.00	$0.0024
Qwen 3.6	$0.30	$1.20	$0.0015

每次 RAG 回答假设 2,810 输入 tokens + 400 输出 tokens

上下文窗口优化

检索更多 chunks = 更好回答但更高成本：

检索 chunks	输入 tokens	GPT-4.1 成本	Claude Sonnet 5 成本
3 chunks	1,786	$0.0068	$0.0113
5 chunks	2,810	$0.0096	$0.0159
10 chunks	5,370	$0.0167	$0.0281
20 chunks	10,490	$0.0310	$0.0525

大多数应用的甜蜜点是 5–10 chunks。超过 10 个回答质量收益递减，而成本线性增长。

每次回答的 RAG 总成本

三层合并，典型配置：

经济配置

嵌入：text-embedding-3-large（摊销 ~$0.001/次）
搜索：自管理 Pinecone（$0.0007/次）
LLM：GPT-4.1-mini + 5 chunks（$0.0019/次）

合计：$0.0036/次（~$0.004）

中档配置

嵌入：text-embedding-v4（摊销 ~$0.012/次）
搜索：托管 API（$0.005/次）
LLM：GPT-4.1 + 5 chunks（$0.0096/次）

合计：$0.0266/次（~$0.03）

高端配置

嵌入：text-embedding-v4（摊销 ~$0.012/次）
搜索：带重排序的托管 API（$0.02/次）
LLM：Claude Sonnet 5 + 10 chunks（$0.0281/次）

合计：$0.0601/次（~$0.06）

月费预估

日查询量	经济 ($0.004)	中档 ($0.03)	高端 ($0.06)
100	$12/月	$90/月	$180/月
1,000	$120/月	$900/月	$1,800/月
10,000	$1,200/月	$9,000/月	$18,000/月

优化策略

1. 分块大小调优

分块大小	同等覆盖需要的 chunks	每次 RAG 调用 tokens	权衡
256 tokens	10 chunks	2,810	更精准，更多搜索成本
512 tokens	5 chunks	2,810	平衡
1024 tokens	3 chunks	3,322	较低精准度，更少搜索

建议： 从 512 tokens、64 token 重叠开始。根据回答质量评估调整。

2. 两阶段检索

# 阶段 1：快速、便宜检索（取 20 候选）
candidates = vector_db.search(query_embedding, top_k=20)

# 阶段 2：用 cross-encoder 重排序（保留 top 5）
reranked = reranker.rank(query, candidates, top_k=5)

# 只将 top 5 发给 LLM
answer = llm.generate(context=reranked, question=query)

重排序每次查询 ~$0.001–0.005，但显著提升到达 LLM 的 chunks 质量，减少大上下文窗口的需求。

3. 缓存

import hashlib

def get_cached_answer(query: str, cache: dict) -> str | None:
    # 精确匹配缓存
    key = hashlib.sha256(query.encode()).hexdigest()
    return cache.get(key)

def get_semantic_cache(query_embedding, cache_embeddings, threshold=0.95):
    # 语义相似缓存
    similarities = cosine_similarity(query_embedding, cache_embeddings)
    if max(similarities) > threshold:
        return cached_answers[argmax(similarities)]
    return None

缓存命中率取决于查询重复度：

• 客户支持：40–60% 命中率（大量重复问题）
• 研究/分析：5–15% 命中率（独特问题）
• 内部知识库：20–40% 命中率

40% 缓存命中率将有效单次成本降低 40%。

4. 模型路由

简单问题用便宜模型，复杂问题用高端模型：

def route_query(query: str, context_chunks: list) -> str:
    if len(context_chunks) <= 3 and len(query.split()) < 15:
        return "gpt-4.1-mini"   # $0.0019/次
    else:
        return "claude-sonnet-5"  # $0.0159/次

60% 简单 / 40% 复杂的分布：

混合成本：0.6 × $0.0019 + 0.4 × $0.0159 = $0.0075/次
vs 始终用高端：$0.0159/次
节省：53%

5. 按场景选择嵌入模型

关于嵌入模型选项包括 text-embedding-v4 的深度分析：

• 纯英文知识库： text-embedding-3-large（最便宜，质量优秀）
• 多语言（含中文）： text-embedding-v4（最佳 CJK 表现）
• 代码仓库： Voyage-3-large（专门优化）
• 预算限制： text-embedding-3-small（便宜 20 倍，90% 质量）

另见嵌入模型全面对比的 benchmark 数据。

RAG vs 长上下文：何时用哪个

百万 token 上下文窗口问世后的问题：RAG 复杂度何时仍然值得？

按文档规模的成本对比

文档集大小	RAG 成本/次	长上下文成本/次（GPT-4.1）	胜出方
10 页（~5K tokens）	$0.03	$0.012	长上下文
50 页（~25K tokens）	$0.03	$0.054	RAG
200 页（~100K tokens）	$0.03	$0.204	RAG（7 倍便宜）
1000 页（~500K tokens）	$0.03	$1.004	RAG（33 倍便宜）
10,000 页（~5M tokens）	$0.03	不可能（超出上下文）	RAG（唯一选择）

交叉点

RAG 比长上下文更便宜的临界点：源材料超过约 15,000–25,000 tokens（~8-12 页），取决于模型定价。

长上下文胜出的场景

1. 小文档集（< 50 页）：直接塞入上下文更便宜更简单
2. 需要整体理解的问题：“总结所有文档的主题”
3. 顺序推理：回答需要跟踪全文线索
4. 一次性分析：单次使用不值得建嵌入基础设施

RAG 胜出的场景

1. 大知识库（> 100 页）：成本随检索 chunks 增长，不随总量增长
2. 高频查询：嵌入摊销成本趋近零
3. 需要精确检索：大集合中查具体事实
4. 多数据源：组合不同类型/来源的文档
5. 动态内容：定期新增文档而无需重新处理全部

实现：最小 RAG 管道

from openai import OpenAI
import numpy as np

client = OpenAI(base_url="https://api.sandbase.ai/v1", api_key="...")

# 步骤 1：嵌入文档（一次性）
def embed_chunks(chunks: list[str]) -> list[list[float]]:
    response = client.embeddings.create(
        model="text-embedding-v4",
        input=chunks
    )
    return [item.embedding for item in response.data]

# 步骤 2：搜索（每次查询）
def search(query: str, chunk_embeddings: np.ndarray, chunks: list[str], top_k=5):
    query_resp = client.embeddings.create(model="text-embedding-v4", input=[query])
    query_vec = np.array(query_resp.data[0].embedding)
    
    similarities = np.dot(chunk_embeddings, query_vec)
    top_indices = np.argsort(similarities)[-top_k:][::-1]
    return [chunks[i] for i in top_indices]

# 步骤 3：生成回答（每次查询）
def answer(query: str, context_chunks: list[str]) -> str:
    context = "\n\n---\n\n".join(context_chunks)
    response = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[
            {"role": "system", "content": f"根据以下上下文回答：\n\n{context}"},
            {"role": "user", "content": query}
        ]
    )
    return response.choices[0].message.content

# 完整管道
chunks = load_and_chunk_documents("./docs/")
embeddings = np.array(embed_chunks(chunks))

# 每次查询成本：~$0.004
query = "退款政策是什么？"
relevant = search(query, embeddings, chunks)
result = answer(query, relevant)

Agent RAG 成本监控

class RAGCostTracker:
    def __init__(self):
        self.embedding_tokens = 0
        self.search_queries = 0
        self.llm_input_tokens = 0
        self.llm_output_tokens = 0
    
    def log_query(self, input_tokens: int, output_tokens: int):
        self.search_queries += 1
        self.llm_input_tokens += input_tokens
        self.llm_output_tokens += output_tokens
    
    @property
    def total_cost(self):
        embedding_cost = self.embedding_tokens / 1000 * 0.0015
        search_cost = self.search_queries * 0.001
        llm_input_cost = self.llm_input_tokens / 1_000_000 * 2.00
        llm_output_cost = self.llm_output_tokens / 1_000_000 * 8.00
        return embedding_cost + search_cost + llm_input_cost + llm_output_cost

关于 API 定价模型和预算控制的深入探讨，见 LLM API 定价指南。

结论

RAG 成本结构可预测且可优化：

• 嵌入：一次性成本，摊到每次查询几乎为零。按语言需求和质量要求选模型。
• 搜索：最便宜的组件。自托管向量库或托管 API，都 < $0.01/次。
• LLM 生成：主导成本。通过模型路由、chunk 数调优和缓存优化。

总计：每次回答 $0.004–0.06，取决于配置。日 1,000 次查询下月费 $120–1,800——远低于人类分析师执行相同知识检索任务的成本。

RAG 在知识库超过 ~25K tokens 且查询频繁、回答需要精确的场景下仍是经济上的正确选择。低于此阈值长上下文更简单更便宜。高于此阈值，RAG 不随集合规模增长的固定单次成本让它成为明确赢家。

Related Reading

• 2026 最佳 RAG Agent 嵌入模型
• text-embedding-v4 深度实战：中英混合 RAG 场景的最优 Embedding 选型
• 2026 LLM API 定价全指南
• 按次 vs 按 Token：Agent 怎么选
• 2026 年最适合 Agent 工作流的 6 个 AI Search API
• Anthropic Prompt Caching 定价拆解：5 分钟 vs 1 小时