GPT-5.6 Luna降价背后：大模型API成本控制与Token管理实战指南

最近在 AI 开发圈里，一个关于“GPT-5.6 Luna”模型降价和 token 用量激增的消息引起了广泛讨论。对于开发者而言，这不仅仅是一个价格新闻，更是一个信号：大模型 API 的成本结构正在发生深刻变化，随之而来的技术挑战（如 token 管理、API 调用优化、错误处理）也变得前所未有的重要。无论是正在集成 AI 能力到现有产品，还是计划开发新的 AI 应用，理解这些变化背后的技术逻辑都至关重要。

本文将从一个开发者的视角，深入拆解“降价”与“用量激增”背后的技术含义。我们会从最基础的token 概念讲起，探讨GPT-5.6 Luna这类模型在OpenRouter等平台上的接入方式，并重点分析因用量变化而凸显的API 调用、错误处理、成本控制等实战问题。文章将包含完整的代码示例、配置思路和排错指南，目标是让你不仅能看懂新闻，更能掌握在真实项目中高效、稳定、经济地使用这类 AI 模型 API 的工程能力。

1. 背景与核心概念：理解市场变化的技术基础

在深入技术细节之前，我们有必要厘清几个关键概念。这能帮助我们理解为什么“降价10倍”和“token用量激增超10倍”会成为开发者社区的热点。

1.1 什么是 GPT-5.6 Luna？

首先需要明确，GPT-5.6 Luna并非 OpenAI 官方发布的模型。根据网络社区的讨论，它很可能指的是通过某些聚合平台（如 OpenRouter）提供的、基于特定技术优化或微调的类 GPT 模型。“Luna”可能是一个内部代号或特定版本标识。对于开发者来说，它的核心价值在于：提供了一个在性能、成本和速率上可能与主流 API（如 GPT-4）形成差异化的选择。

在技术选型时，我们应将其视为一个可通过标准 OpenAI API 兼容接口调用的第三方模型。这意味着，你可以使用熟悉的openaiPython 库或 HTTP 请求，只需将请求的终端节点（endpoint）和 API Key 替换为对应平台的即可。

1.2 Token：大模型世界的“计价单元”与“信息碎片”

Token是大语言模型处理文本的基本单位。它不等同于单词或汉字。例如：

• 英文单词 “hello” 可能被拆成 1 个 token。
• 单词 “unbelievable” 可能被拆成 “un”, “believe”, “able” 3 个 token。
• 一个常见的中文字符通常就是 1 个 token。

为什么 Token 如此重要？

1. 计费核心：绝大多数大模型 API 按 token 消耗量计费，包括输入的提示（prompt）和模型生成的输出（completion）。
2. 上下文限制：模型有上下文窗口限制（如 8K, 32K, 128K tokens），这直接决定了单次对话能处理的信息量。
3. 性能影响：处理的 token 数量直接影响 API 响应时间和计算资源消耗。

“Token 用量激增超 10 倍”这一现象，可能源于几个技术原因：模型上下文窗口变大、用户提交更长的提示词、模型生成了更长的内容，或者应用场景从简单问答转向了长文档处理、代码生成等。这对开发者的 token 计数和成本预估能力提出了更高要求。

1.3 OpenRouter：模型聚合平台的技术角色

OpenRouter是一个 AI 模型聚合平台。你可以把它想象成一个“模型超市”或“API 网关”。它统一了接入众多大模型（包括 Claude、GPT 系列、开源模型等）的接口，让开发者用一个 API Key 和一套相似的调用格式，就能访问不同供应商的模型。

对开发者的价值：

• 简化集成：无需为每个模型供应商单独注册、管理 API Key 和适配调用方式。
• 成本对比：可以实时查询不同模型的定价，选择性价比最高的。
• 冗余与降级：当某个模型服务不稳定时，可以快速切换备用模型。

然而，使用这类平台也引入了新的技术考量，比如网络中转的延迟、平台自身的稳定性（热词中出现的token exchange failed等错误）、以及平台定价与模型官方定价的差异。

2. 环境准备与工具选择

在开始编码之前，我们需要搭建一个可以实验和验证的开发环境。本节将介绍从零开始，准备一个用于调用类似 GPT-5.6 Luna 模型 API 的 Python 开发环境。

2.1 基础环境配置

我们选择 Python 作为主要语言，因为它拥有最丰富的大模型开发生态。

操作系统：Windows 10/11, macOS, 或 Linux (如 Ubuntu 20.04+) 均可。Python 版本：推荐使用 Python 3.8 至 3.11 的稳定版本。避免使用最新的预览版，以防库依赖不兼容。

首先，检查你的 Python 环境：

python --version # 或 python3 --version

建议使用虚拟环境来隔离项目依赖，避免污染全局环境。

# 创建虚拟环境 python -m venv venv # 激活虚拟环境 # Windows (PowerShell) .\venv\Scripts\Activate.ps1 # Windows (CMD) .\venv\Scripts\activate.bat # macOS / Linux source venv/bin/activate

激活后，命令行提示符前会出现(venv)标识。

2.2 核心依赖库安装

我们将主要使用openai这个官方库（它兼容许多提供 OpenAI 格式接口的平台），以及用于处理 HTTP 请求的requests库。

# 安装 openai 库。注意：即使调用非OpenAI官方模型，也常使用此库的格式。 pip install openai # 安装 requests 库，用于更底层的 HTTP 调用演示 pip install requests # 安装 tiktoken 库，用于精确计算 prompt 的 token 数量（非常重要！） pip install tiktoken # 可选：安装 python-dotenv 用于管理环境变量（最佳实践） pip install python-dotenv

2.3 获取 API 密钥

要调用任何大模型 API，你都需要一个 API Key。这里以OpenRouter为例（请注意，平台可用性可能随时变化，请以官方信息为准）：

1. 访问 OpenRouter 官网并注册账号。
2. 在控制台（Dashboard）找到你的 API Key。它通常是一串以sk-or-开头的字符串。
3. 重要：永远不要将 API Key 直接硬编码在代码中，尤其是提交到 Git 仓库。我们将使用环境变量来管理。

创建一个名为.env的文件在你的项目根目录下：

# .env 文件内容 OPENROUTER_API_KEY=sk-or-你的实际密钥 OPENROUTER_API_BASE=https://openrouter.ai/api/v1

然后，创建一个.gitignore文件，确保.env不会被提交：

# .gitignore .env venv/ __pycache__/ *.pyc

3. 核心原理与 API 调用拆解

掌握了环境和基础概念后，我们来深入技术核心：如何正确地调用 API，并理解其背后的每个参数。

3.1 OpenAI 兼容 API 的通用请求格式

无论是 OpenAI 官方，还是 OpenRouter，其兼容接口通常接受一个结构化的 JSON 请求。一个最基础的聊天补全（Chat Completion）请求如下：

{ "model": "gpt-3.5-turbo", "messages": [ {"role": "system", "content": "你是一个有帮助的助手。"}, {"role": "user", "content": "你好，世界！"} ], "max_tokens": 500, "temperature": 0.7 }

• model: 指定要使用的模型标识符。在 OpenRouter 上，你需要使用其平台特定的模型名，例如openai/gpt-3.5-turbo或传闻中的某供应商/gpt-5.6-luna。
• messages: 一个消息对象数组，定义了对话上下文。role可以是system（设定助手行为）、user（用户输入）、assistant（助手历史回复）。
• max_tokens: 限制模型生成内容的最大 token 数。这是控制单次调用成本的关键参数。
• temperature: 控制输出的随机性（0-2）。值越低输出越确定、保守；值越高输出越随机、有创造性。

3.2 使用openai库进行调用（推荐）

这是最简洁的方式。我们通过修改openai库的客户端配置，将其指向 OpenRouter 的终端节点。

# file: call_openrouter.py import os from openai import OpenAI from dotenv import load_dotenv # 1. 加载环境变量 load_dotenv() # 2. 初始化客户端，指向 OpenRouter client = OpenAI( api_key=os.getenv("OPENROUTER_API_KEY"), base_url=os.getenv("OPENROUTER_API_BASE") ) # 3. 发起聊天补全请求 try: response = client.chat.completions.create( model="openai/gpt-3.5-turbo", # 此处替换为目标模型，如 `某供应商/gpt-5.6-luna` messages=[ {"role": "system", "content": "你是一位资深技术专家，回答简洁专业。"}, {"role": "user", "content": "请用Python写一个函数，计算斐波那契数列的第n项。"} ], max_tokens=300, temperature=0.5 ) # 4. 提取并打印回复 assistant_reply = response.choices[0].message.content print("助手回复：") print(assistant_reply) # 5. 查看使用量（关键！） usage = response.usage print(f"\n本次调用Token使用情况：") print(f" 提示词Token (Prompt Tokens): {usage.prompt_tokens}") print(f" 生成Token (Completion Tokens): {usage.completion_tokens}") print(f" 总计Token (Total Tokens): {usage.total_tokens}") except Exception as e: print(f"API调用发生错误：{e}")

代码解释与注意事项：

• 我们通过base_url参数将客户端重定向到 OpenRouter。
• model参数必须使用 OpenRouter 支持的完整模型标识符。你需要在其官方文档或 Playground 中查询准确的模型名。
• 务必捕获异常 (try-except)，网络请求和远程 API 调用是不稳定的。
• 重点：response.usage对象包含了本次调用的 token 消耗明细，这是进行成本核算和用量监控的直接数据来源。

3.3 使用requests库进行底层调用

有时你可能需要更灵活的控制，或者使用的平台有细微的接口差异。这时可以直接使用requests。

# file: call_openrouter_direct.py import os import requests import json from dotenv import load_dotenv load_dotenv() api_key = os.getenv("OPENROUTER_API_KEY") api_base = os.getenv("OPENROUTER_API_BASE") url = f"{api_base}/chat/completions" headers = { "Authorization": f"Bearer {api_key}", "Content-Type": "application/json", # OpenRouter 可能需要额外的头部信息，例如指定推荐来源 "HTTP-Referer": "https://your-site.com", # 可选，你的网站URL "X-Title": "My AI App", # 可选，你的应用名称 } payload = { "model": "openai/gpt-3.5-turbo", "messages": [ {"role": "user", "content": "解释一下什么是递归。"} ], "max_tokens": 150 } try: response = requests.post(url, headers=headers, data=json.dumps(payload)) response.raise_for_status() # 如果状态码不是200，抛出HTTPError result = response.json() print("回复内容：", result["choices"][0]["message"]["content"]) print("Token 使用：", result["usage"]) except requests.exceptions.HTTPError as http_err: print(f"HTTP错误发生：{http_err}") print(f"响应内容：{response.text}") # 打印错误详情 except Exception as err: print(f"其他错误发生：{err}")

为什么需要了解底层调用？

1. 错误诊断：当使用高级库出错时，底层调用能让你看到原始的 HTTP 响应，更容易定位问题是出在库、网络还是 API 服务本身。
2. 自定义需求：某些平台可能有特殊的请求头或参数，直接使用requests可以更灵活地添加。
3. 理解原理：有助于你理解整个交互流程，而不是仅仅作为一个“黑盒”使用者。

4. 实战：构建一个带用量监控与成本估算的简单聊天客户端

现在，我们将综合运用前面的知识，构建一个简单的命令行聊天客户端。这个客户端的核心特点是：实时计算 token 消耗，并估算成本。这正是应对“用量激增”场景必须掌握的能力。

4.1 项目结构设计

gpt-luna-cost-demo/ ├── .env # 存储API密钥（不上传Git） ├── .gitignore ├── requirements.txt # 项目依赖 ├── token_counter.py # Token计数工具模块 ├── cost_estimator.py # 成本估算模块 └── chat_client.py # 主聊天客户端

4.2 创建依赖文件

requirements.txt:

openai>=1.0.0 requests>=2.28.0 tiktoken>=0.5.0 python-dotenv>=1.0.0

4.3 实现 Token 计数工具

精确计算 prompt 的 token 数对于预算控制至关重要。我们将使用tiktoken库。注意，不同模型的编码方式不同，需要指定正确的编码。

# file: token_counter.py import tiktoken class TokenCounter: """ 用于计算文本token数量的工具类。 注意：不同模型使用不同的编码器，计算需匹配。 """ # 一个简单的模型到编码的映射（需要根据实际使用的模型扩展） MODEL_ENCODING_MAP = { # OpenAI 模型 "gpt-3.5-turbo": "cl100k_base", "gpt-4": "cl100k_base", "gpt-4-turbo-preview": "cl100k_base", # 假设 GPT-5.6 Luna 也使用 cl100k_base，实际需确认 "gpt-5.6-luna": "cl100k_base", # 其他模型... } @staticmethod def count_tokens_for_model(model_name: str, text: str) -> int: """ 为指定模型计算一段文本的token数量。 Args: model_name: 模型名称，如 'gpt-3.5-turbo' text: 要计算的文本 Returns: token数量 """ # 获取编码名称，如果未映射则使用默认值（cl100k_base是较新的OpenAI模型通用编码） encoding_name = TokenCounter.MODEL_ENCODING_MAP.get(model_name, "cl100k_base") try: encoding = tiktoken.get_encoding(encoding_name) except KeyError: # 如果编码不存在，回退到近似计算（按字符数粗略估算） print(f"警告：未找到模型 '{model_name}' 的精确编码 '{encoding_name}'，使用字符数/4进行粗略估算。") # 这是一个非常粗略的估算，英文约1 token=4字符，中文约1 token=2字符。 # 实际应用中应尽量获取精确编码。 return len(text) // 4 if text.isascii() else len(text) // 2 return len(encoding.encode(text)) @staticmethod def count_tokens_in_messages(model_name: str, messages: list) -> int: """ 计算一个消息列表的总token数。 参考OpenAI的计算方式：消息格式本身也会消耗少量token。 这是一个简化版，对于精确预算，建议直接使用API返回的 usage.prompt_tokens。 """ total_tokens = 0 for message in messages: # 计算每条消息内容的token total_tokens += TokenCounter.count_tokens_for_model(model_name, message["content"]) # 为角色名和消息结构添加一些token（近似值） total_tokens += 5 # 为整个消息列表的结尾添加token total_tokens += 3 return total_tokens # 示例用法 if __name__ == "__main__": counter = TokenCounter() sample_text = "Hello, world! 你好，世界！" model = "gpt-3.5-turbo" token_count = counter.count_tokens_for_model(model, sample_text) print(f"文本 '{sample_text}' 对于模型 '{model}' 的token数约为：{token_count}")

4.4 实现成本估算模块

我们需要知道模型的价格。价格信息通常需要从平台文档动态获取。这里我们硬编码一个示例价格表，实际项目中应从配置或API加载。

# file: cost_estimator.py class CostEstimator: """ 根据token使用量和模型单价估算成本。 价格单位通常是 美元/每千token (USD per 1K tokens)。 """ # 示例价格表 (虚构数据，仅用于演示) # 格式: { "模型标识符": {"input": 价格, "output": 价格} } # 价格单位：美元 / 1K tokens MODEL_PRICES = { "openai/gpt-3.5-turbo": {"input": 0.0010, "output": 0.0020}, # $0.001 / 1K input, $0.002 / 1K output "openai/gpt-4": {"input": 0.03, "output": 0.06}, # 假设 GPT-5.6 Luna 降价后的价格 "某供应商/gpt-5.6-luna": {"input": 0.0005, "output": 0.0010}, # 假设输入$0.0005，输出$0.001 / 1K tokens } @staticmethod def estimate_cost(model: str, prompt_tokens: int, completion_tokens: int) -> float: """ 估算一次API调用的成本。 Args: model: 模型标识符 prompt_tokens: 提示词token数 completion_tokens: 生成内容token数 Returns: 估算的成本（美元） """ price_info = CostEstimator.MODEL_PRICES.get(model) if not price_info: print(f"警告：未找到模型 '{model}' 的价格信息，无法估算成本。") return 0.0 # 计算成本： (token数 / 1000) * 每千token价格 input_cost = (prompt_tokens / 1000) * price_info["input"] output_cost = (completion_tokens / 1000) * price_info["output"] total_cost = input_cost + output_cost return total_cost @staticmethod def format_cost(cost_usd: float) -> str: """格式化成本显示""" if cost_usd < 0.001: return f"${cost_usd*1000:.3f} 毫美分" elif cost_usd < 1: return f"${cost_usd*100:.2f} 美分" else: return f"${cost_usd:.4f}" # 示例用法 if __name__ == "__main__": estimator = CostEstimator() cost = estimator.estimate_cost("某供应商/gpt-5.6-luna", 1500, 800) print(f"估算成本：{CostEstimator.format_cost(cost)}") # 对比GPT-3.5-Turbo cost_35 = estimator.estimate_cost("openai/gpt-3.5-turbo", 1500, 800) print(f"GPT-3.5-Turbo 对比成本：{CostEstimator.format_cost(cost_35)}")

4.5 实现主聊天客户端

现在，我们将所有模块组合起来，创建一个交互式命令行客户端。

# file: chat_client.py import os import json from openai import OpenAI from dotenv import load_dotenv from token_counter import TokenCounter from cost_estimator import CostEstimator class AIChatClient: def __init__(self, model: str = "openai/gpt-3.5-turbo"): """ 初始化AI聊天客户端。 Args: model: 要使用的模型标识符 """ load_dotenv() self.model = model self.client = OpenAI( api_key=os.getenv("OPENROUTER_API_KEY"), base_url=os.getenv("OPENROUTER_API_BASE") ) self.conversation_history = [] self.total_prompt_tokens = 0 self.total_completion_tokens = 0 def add_system_message(self, content: str): """添加系统指令""" self.conversation_history.append({"role": "system", "content": content}) def chat_round(self, user_input: str, max_tokens: int = 500, temperature: float = 0.7) -> str: """ 进行一轮对话。 Returns: 模型的回复文本 """ # 1. 添加用户消息到历史 self.conversation_history.append({"role": "user", "content": user_input}) # 2. 在发送前估算本次请求的prompt token数（可选，用于预警） estimated_prompt_tokens = TokenCounter.count_tokens_in_messages(self.model, self.conversation_history) print(f"[预估] 本次请求Prompt Token数: ~{estimated_prompt_tokens}") try: # 3. 调用API response = self.client.chat.completions.create( model=self.model, messages=self.conversation_history, max_tokens=max_tokens, temperature=temperature ) # 4. 获取回复 assistant_reply = response.choices[0].message.content # 5. 添加助手回复到历史 self.conversation_history.append({"role": "assistant", "content": assistant_reply}) # 6. 记录使用量 usage = response.usage self.total_prompt_tokens += usage.prompt_tokens self.total_completion_tokens += usage.completion_tokens # 7. 打印本次开销 cost = CostEstimator.estimate_cost( self.model, usage.prompt_tokens, usage.completion_tokens ) print(f"[开销] 本次消耗: {usage.prompt_tokens}(输入) + {usage.completion_tokens}(输出) = {usage.total_tokens} tokens") print(f"[开销] 本次估算成本: {CostEstimator.format_cost(cost)}") # 8. 打印累计开销 total_cost = CostEstimator.estimate_cost( self.model, self.total_prompt_tokens, self.total_completion_tokens ) print(f"[累计] 总Token: {self.total_prompt_tokens + self.total_completion_tokens}") print(f"[累计] 总估算成本: {CostEstimator.format_cost(total_cost)}") print("-" * 50) return assistant_reply except Exception as e: print(f"[错误] API调用失败: {e}") # 从历史中移除失败的用户消息，避免影响下次请求 self.conversation_history.pop() return f"请求失败: {e}" def run_interactive(self): """运行交互式聊天循环""" print(f"=== AI 聊天客户端 (模型: {self.model}) ===") print("输入 'quit' 或 'exit' 退出程序") print("输入 'clear' 或 '重置' 清空对话历史") print("输入 'history' 查看对话历史") print("="*50) # 可选：添加初始系统指令 system_prompt = input("请输入系统指令（直接回车跳过）: ").strip() if system_prompt: self.add_system_message(system_prompt) print(f"[系统] 已设置系统指令: {system_prompt[:50]}...") while True: try: user_input = input("\n[你] > ").strip() if user_input.lower() in ['quit', 'exit', 'q']: print("再见！") break elif user_input.lower() in ['clear', 'reset', '重置', '清空']: self.conversation_history = [] self.total_prompt_tokens = 0 self.total_completion_tokens = 0 print("[系统] 对话历史已清空。") continue elif user_input.lower() in ['history', '历史']: print("\n=== 对话历史 ===") for msg in self.conversation_history: role_display = {"system": "系统", "user": "你", "assistant": "AI"}.get(msg["role"], msg["role"]) # 截断长内容 content_preview = msg["content"][:100] + "..." if len(msg["content"]) > 100 else msg["content"] print(f"{role_display}: {content_preview}") print("="*30) continue elif not user_input: continue # 进行聊天 print("\n[AI] 思考中...") reply = self.chat_round(user_input) print(f"[AI] > {reply}") except KeyboardInterrupt: print("\n\n程序被中断。") break except Exception as e: print(f"\n[错误] 发生未预期错误: {e}") if __name__ == "__main__": # 在这里指定你想使用的模型 # MODEL = "openai/gpt-3.5-turbo" MODEL = "某供应商/gpt-5.6-luna" # 假设的模型名 client = AIChatClient(model=MODEL) client.run_interactive()

4.6 运行与验证

1. 确保你的.env文件已正确配置 OpenRouter 的 API Key 和 Base URL。
2. 在项目根目录下，安装依赖：pip install -r requirements.txt
3. 运行客户端：python chat_client.py
4. 按照提示操作。你可以尝试问几个问题，观察控制台输出的 token 消耗和成本估算。

预期效果：

• 每次对话都会显示本次和累计的 token 使用量。
• 会根据预设的模型单价估算本次和累计的成本（美元）。
• 你可以直观地比较使用不同模型（如 GPT-3.5-Turbo 和假设降价的 GPT-5.6 Luna）的成本差异。

这个实战项目虽然简单，但它包含了生产级 AI 应用的核心要素：API 调用、对话历史管理、Token 计量和成本监控。通过扩展这个客户端（例如添加流式响应、函数调用、持久化历史记录等功能），你可以构建出更复杂的应用。

5. 常见问题与排查思路

在实际集成和使用过程中，你几乎一定会遇到各种错误。下面将结合网络热词中频繁出现的错误信息，提供一个排查指南。

6. 最佳实践与工程建议

为了在“降价”和“用量激增”的背景下，构建出稳定、高效、可控的 AI 应用，以下工程最佳实践至关重要。

6.1 成本控制与用量监控

1. 预算硬限制：在应用层面设置每日/每周/每月的 token 消耗或金额预算。一旦接近阈值，自动触发告警或停止服务。

   class BudgetManager: def __init__(self, daily_budget_usd): self.daily_budget = daily_budget_usd self.today_usage = 0.0 self.last_reset_date = datetime.date.today() def can_make_request(self, estimated_cost): self._reset_if_new_day() if self.today_usage + estimated_cost > self.daily_budget: return False return True def record_usage(self, actual_cost): self.today_usage += actual_cost

2. 分级使用策略：根据任务重要性选择不同成本的模型。例如，简单问答用廉价模型，复杂创作再用高级模型。
3. 缓存机制：对频繁出现的、结果确定的查询（如“今天的日期”、“公司的产品介绍”）进行结果缓存，避免重复调用。
4. Token 使用分析：定期分析日志，识别哪些用户、哪些类型的请求消耗 token 最多，优化提示词或流程。

6.2 提升稳定性与健壮性

1. 实现重试与退避：对于网络超时、速率限制（429错误）等临时性故障，必须实现带指数退避的重试机制。

   import time from tenacity import retry, stop_after_attempt, wait_exponential @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10)) def call_ai_api_with_retry(client, messages): # 这个函数会被自动重试最多3次，等待时间指数增长 return client.chat.completions.create(model="gpt-3.5-turbo", messages=messages)

   （使用前需安装tenacity库：pip install tenacity）
2. 设置超时：为 API 调用设置合理的超时时间（如 30 秒），避免线程阻塞。
3. 熔断与降级：当某个模型 API 连续失败时，暂时“熔断”对其的请求，并切换到备用模型或返回兜底内容。
4. 输入验证与清理：对用户输入进行清理，防止注入恶意提示词导致模型输出异常或消耗过多 token。

6.3 提示词工程优化

1. 结构化提示词：使用清晰的格式（如 Markdown、XML 标签）来组织系统指令、用户输入和上下文，提高模型理解准确性，减少无效输出。
2. 限制输出格式：明确要求模型以特定格式（如 JSON、列表、特定关键词）回复，便于后续程序化处理，避免解析错误。
3. 上下文管理：对于长对话，不要无限制地累积历史。可以：
   • 滑动窗口：只保留最近 N 轮对话。
   • 总结压缩：当历史过长时，调用模型对之前的对话进行总结，然后用总结作为新的上下文。
   • 按主题分段：将长对话按主题拆分成多个独立的会话。

6.4 安全与合规

1. 密钥管理：API Key 必须通过环境变量、密钥管理服务（如 AWS Secrets Manager、HashiCorp Vault）等方式管理，绝对禁止写入代码或配置文件并提交到代码仓库。
2. 内容审核：对于面向公众的应用，必须对用户输入和模型输出进行内容安全审核，防止生成有害、偏见或违法信息。
3. 用户数据隐私：避免在提示词中发送用户个人身份信息（PII）。如需处理，应先进行脱敏。
4. 遵守平台政策：仔细阅读并遵守你所使用的 API 平台（如 OpenRouter）的服务条款、使用政策和合规要求。

6.5 可观测性与日志

1. 记录详细日志：记录每一次 API 调用的时间戳、模型、请求 token 数、响应 token 数、耗时、成本估算以及是否成功。这对于排查问题和成本分析至关重要。
2. 设置监控告警：对 API 错误率、响应延迟、token 消耗速率设置监控告警。
3. 使用 Tracing：在分布式系统中，使用 OpenTelemetry 等工具对 AI 调用链进行追踪，便于定位性能瓶颈。

通过将上述最佳实践融入到你的项目中，你可以构建出一个不仅功能强大，而且经济、稳定、安全的 AI 应用，从容应对模型市场变化带来的挑战与机遇。