从OpenAI Codex迁移到国产大模型：DeepSeek与Qwen的API适配实战指南

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度

在实际开发中，我们常常需要将项目从依赖 OpenAI 的 GPT 系列模型（如 Codex）迁移到国产大语言模型，例如 DeepSeek 或 Qwen（通义千问）。这种迁移不仅是技术选型的调整，更涉及到 API 接口、请求参数、响应格式、上下文管理乃至提示工程（Prompt Engineering）的全面适配。很多开发者尝试时，会卡在 API 密钥格式不对、模型名称找不到、返回数据结构解析失败等看似简单却耗费大量时间的问题上。

本文旨在提供一份可直接落地的实操指南，帮助你理解从 Codex 到国产模型的迁移核心差异，并一步步完成 DeepSeek 和 Qwen 的接入。我们将从环境准备、API 密钥获取、最小化请求示例开始，逐步深入到流式响应处理、上下文长度管理、以及生产环境中的错误处理和性能优化。无论你是在重构一个旧的 AI 应用，还是在新项目中直接选用国产模型，都能通过本文获得清晰的路径和可复现的代码。

1. 理解迁移的核心：API 差异与概念映射

直接从 OpenAI 切换到国产模型，最大的障碍不是模型能力，而是接口协议的不一致。OpenAI 的 API 设计已经成为一种事实标准，但国内各大厂商的 API 在细节上各有不同。成功迁移的关键在于准确理解这些差异并进行映射。

1.1 核心概念对照表

首先，我们需要建立一个基本概念的映射关系。下表列出了 OpenAI (Codex/GPT) 与 DeepSeek、Qwen 在 API 层面最关键的几个对应点：

从上表可以看出，DeepSeek 的 API 设计高度兼容 OpenAI，这降低了迁移成本。而 Qwen 通过阿里云的 DashScope 平台提供服务，其接口路径和部分响应字段有所不同，需要特别注意。

1.2 上下文长度 (Context Length) 与 Token 计算

另一个关键差异是模型的上下文窗口大小。Codex 的上下文长度是 4096 tokens。而国产模型在这方面各有优势：

• DeepSeek ：最新版本支持 128K 上下文。
• Qwen ：Qwen2.5 系列模型支持 128K 甚至 1M 的上下文。

在迁移时，如果你的原有应用接近或超过了 Codex 的 4K 限制，切换到国产模型可能直接解决了上下文不足的问题。但需要注意的是，更长的上下文意味着单次请求可能消耗更多 tokens，成本计算方式需要查看对应平台的计价规则。

Token 的计算方式（如一个汉字约等于 2个 tokens）在不同模型间是相似的，但具体的分词器（Tokenizer）不同。对于精确的成本控制或截断处理，建议使用各平台官方提供的 SDK 或分词工具。

2. 环境准备与依赖配置

在开始编写代码之前，需要完成账户注册、API 密钥获取和项目依赖配置。

2.1 获取 API 密钥

1. DeepSeek ：

   • 访问 DeepSeek 开放平台官网并注册。
   • 在控制台中创建 API 密钥（API Key），通常以 sk- 开头。
   • 部分模型（如 deepseek-coder ）可能需要单独申请试用或具备一定条件。

2. Qwen (通义千问) ：

   • 访问阿里云 DashScope 灵积模型服务平台。
   • 完成阿里云账号注册、实名认证。
   • 在 DashScope 控制台开通“通义千问”服务，并创建 API 密钥。同样以 sk- 开头。
   • 注意：新用户通常有一定额度的免费 tokens 可供试用。

2.2 项目依赖配置

我们将使用 Python 的 requests 库进行最基础的 HTTP 调用，这能最清晰地展示 API 细节。生产环境可以考虑使用官方 SDK。

在你的项目目录中，创建并激活虚拟环境，然后安装依赖：

# 创建项目目录
mkdir ai-model-migration && cd ai-model-migration
# 创建虚拟环境 (Python 3.8+)
python -m venv venv
# 激活虚拟环境
# Windows: venv\Scripts\activate
# Linux/Mac: source venv/bin/activate
# 安装依赖
pip install requests

接下来，创建一个 .env 文件来安全地存储你的 API 密钥，并使用 python-dotenv 读取。首先安装它：

pip install python-dotenv

然后创建 .env 文件：

# .env
DEEPSEEK_API_KEY=your_deepseek_api_key_here
QWEN_API_KEY=your_qwen_api_key_here
# 可选：如果你还在使用 OpenAI
OPENAI_API_KEY=your_openai_api_key_here

重要 ：确保将 .env 添加到你的 .gitignore 文件中，避免密钥泄露。

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

3. 实现基础的非流式调用

我们从最简单的非流式（同步）调用开始，这是功能验证的基础。

3.1 构建一个通用的请求函数

为了便于比较和切换，我们先编写一个支持多模型的通用请求函数。创建文件 basic_call.py ：

# basic_call.py
import os
import json
import requests
from dotenv import load_dotenv

# 加载 .env 文件中的环境变量
load_dotenv()

def call_openai_style_api(api_url, api_key, model, messages, temperature=0.7, max_tokens=1024):
    """
    调用 OpenAI 兼容格式的 API (如 DeepSeek)
    """
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    payload = {
        "model": model,
        "messages": messages,
        "temperature": temperature,
        "max_tokens": max_tokens,
        "stream": False  # 非流式
    }
    try:
        response = requests.post(api_url, headers=headers, json=payload, timeout=30)
        response.raise_for_status()  # 如果状态码不是200，抛出HTTPError异常
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"请求失败: {e}")
        if hasattr(e, 'response') and e.response is not None:
            print(f"响应状态码: {e.response.status_code}")
            print(f"响应内容: {e.response.text}")
        return None

def call_qwen_api(api_key, model, messages, temperature=0.7, max_tokens=1024):
    """
    调用 Qwen (DashScope) API
    注意：DashScope 的请求体和响应体格式与 OpenAI 不同
    """
    api_url = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    # DashScope 的请求格式
    payload = {
        "model": model,
        "input": {
            "messages": messages
        },
        "parameters": {
            "temperature": temperature,
            "max_tokens": max_tokens,
            "result_format": "message"  # 指定返回消息格式
        }
    }
    try:
        response = requests.post(api_url, headers=headers, json=payload, timeout=30)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"请求失败: {e}")
        if hasattr(e, 'response') and e.response is not None:
            print(f"响应状态码: {e.response.status_code}")
            print(f"响应内容: {e.response.text}")
        return None

def parse_openai_response(response_data):
    """解析 OpenAI 兼容格式的响应"""
    if not response_data:
        return "无响应数据"
    try:
        # DeepSeek 和 OpenAI 格式一致
        content = response_data['choices'][0]['message']['content']
        return content.strip()
    except KeyError as e:
        return f"解析响应内容失败，KeyError: {e}，原始响应: {json.dumps(response_data, indent=2, ensure_ascii=False)}"

def parse_qwen_response(response_data):
    """解析 Qwen (DashScope) 格式的响应"""
    if not response_data:
        return "无响应数据"
    try:
        # DashScope 返回格式
        content = response_data['output']['choices'][0]['message']['content']
        return content.strip()
    except KeyError as e:
        return f"解析响应内容失败，KeyError: {e}，原始响应: {json.dumps(response_data, indent=2, ensure_ascii=False)}"

if __name__ == "__main__":
    # 定义对话消息，格式是通用的
    messages = [
        {"role": "system", "content": "你是一个乐于助人的编程助手。"},
        {"role": "user", "content": "用Python写一个函数，计算斐波那契数列的第n项。"}
    ]

    print("=== 测试 DeepSeek ===")
    deepseek_response = call_openai_style_api(
        api_url="https://api.deepseek.com/chat/completions",
        api_key=os.getenv("DEEPSEEK_API_KEY"),
        model="deepseek-chat",
        messages=messages
    )
    print(f"DeepSeek 回答:\n{parse_openai_response(deepseek_response)}\n")

    print("=== 测试 Qwen ===")
    qwen_response = call_qwen_api(
        api_key=os.getenv("QWEN_API_KEY"),
        model="qwen-turbo", # 或 qwen-plus, qwen-max
        messages=messages
    )
    print(f"Qwen 回答:\n{parse_qwen_response(qwen_response)}")

运行这个脚本前，请确保 .env 文件中的密钥已正确填写。

python basic_call.py

如果一切正常，你将看到 DeepSeek 和 Qwen 分别生成的斐波那契数列函数代码。这个示例清晰地展示了两种 API 在调用和解析上的主要区别。

3.2 关键参数解释与调整

在迁移过程中，理解并正确设置以下参数至关重要：

• temperature (温度) ：控制输出的随机性。值越低（如 0.2），输出越确定、保守；值越高（如 0.8），输出越随机、有创造性。 迁移建议 ：如果你在原 Codex 应用中使用的是默认值（如 0.7），可以先保持相同值进行测试，再根据输出结果微调。代码生成任务通常需要较低的 temperature （如 0.1-0.3）以保证稳定性。
• max_tokens ：限制模型单次响应生成的最大 tokens 数。 迁移注意点 ：不同模型对单次响应的 tokens 上限不同，需要查阅对应平台的文档。设置过低会导致回答被截断。
• messages 列表 ：对话历史。 system 角色设置全局指令， user 和 assistant 交替构成对话。 迁移关键 ：这是迁移中最容易直接复用的部分。确保你的消息列表格式正确，特别是角色名称拼写。
• model ：指定使用的模型。这是必须根据平台更改的参数。DeepSeek 常用 deepseek-chat （通用对话）和 deepseek-coder （代码专用）。Qwen 常用 qwen-turbo （快速）、 qwen-plus （均衡）、 qwen-max （最强能力）。

4. 处理流式响应 (Streaming)

对于需要长时间生成文本或希望实现打字机效果的应用，流式响应（Server-Sent Events, SSE）是必备功能。幸运的是，DeepSeek 和 Qwen 都支持该功能。

4.1 实现流式响应处理

创建文件 streaming_call.py ：

# streaming_call.py
import os
import json
import requests
from dotenv import load_dotenv

load_dotenv()

def stream_from_deepseek(messages, model="deepseek-chat"):
    """从 DeepSeek 流式获取响应"""
    api_url = "https://api.deepseek.com/chat/completions"
    api_key = os.getenv("DEEPSEEK_API_KEY")
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    payload = {
        "model": model,
        "messages": messages,
        "temperature": 0.7,
        "stream": True  # 开启流式
    }
    try:
        response = requests.post(api_url, headers=headers, json=payload, stream=True, timeout=60)
        response.raise_for_status()
        print(f"DeepSeek ({model}) 流式响应: ", end="", flush=True)
        full_content = []
        for line in response.iter_lines():
            if line:
                line_decoded = line.decode('utf-8')
                if line_decoded.startswith('data: '):
                    data_str = line_decoded[6:]  # 去掉 'data: ' 前缀
                    if data_str == '[DONE]':
                        print()  # 换行
                        break
                    try:
                        data = json.loads(data_str)
                        delta = data.get('choices', [{}])[0].get('delta', {})
                        content_piece = delta.get('content', '')
                        if content_piece:
                            print(content_piece, end='', flush=True)
                            full_content.append(content_piece)
                    except json.JSONDecodeError:
                        # 忽略非JSON数据行
                        continue
        return ''.join(full_content)
    except requests.exceptions.RequestException as e:
        print(f"\nDeepSeek 流式请求失败: {e}")
        return None

def stream_from_qwen(messages, model="qwen-turbo"):
    """从 Qwen (DashScope) 流式获取响应"""
    api_url = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"
    api_key = os.getenv("QWEN_API_KEY")
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    # DashScope 流式请求体
    payload = {
        "model": model,
        "input": {
            "messages": messages
        },
        "parameters": {
            "temperature": 0.7,
            "result_format": "message"
        },
        "stream": True  # DashScope 也使用 stream 字段控制
    }
    try:
        response = requests.post(api_url, headers=headers, json=payload, stream=True, timeout=60)
        response.raise_for_status()
        print(f"Qwen ({model}) 流式响应: ", end="", flush=True)
        full_content = []
        for line in response.iter_lines():
            if line:
                line_decoded = line.decode('utf-8')
                # DashScope 流式响应格式可能与 OpenAI 略有不同，需要适配
                # 常见格式是每行一个 JSON 对象
                if line_decoded.startswith('data:'):
                    data_str = line_decoded[5:].strip()
                else:
                    data_str = line_decoded.strip()
                if not data_str or data_str == '[DONE]':
                    continue
                try:
                    data = json.loads(data_str)
                    # 根据 DashScope 实际返回结构解析，这里是一个常见示例
                    # 实际结构请以官方文档为准，可能需要调整
                    choices = data.get('output', {}).get('choices', [{}])
                    if choices:
                        content_piece = choices[0].get('message', {}).get('content', '')
                        if content_piece:
                            print(content_piece, end='', flush=True)
                            full_content.append(content_piece)
                except json.JSONDecodeError:
                    # 忽略非JSON数据行
                    continue
        print()  # 换行
        return ''.join(full_content)
    except requests.exceptions.RequestException as e:
        print(f"\nQwen 流式请求失败: {e}")
        return None

if __name__ == "__main__":
    messages = [
        {"role": "user", "content": "简要解释一下什么是递归，并给出一个简单的例子。"}
    ]
    # 测试 DeepSeek 流式
    deepseek_result = stream_from_deepseek(messages, model="deepseek-chat")
    print(f"\nDeepSeek 完整回答已接收，长度：{len(deepseek_result) if deepseek_result else 0}\n")
    # 测试 Qwen 流式
    qwen_result = stream_from_qwen(messages, model="qwen-turbo")
    print(f"\nQwen 完整回答已接收，长度：{len(qwen_result) if qwen_result else 0}")

运行此脚本，你将看到回答内容逐词或逐句地打印出来，模拟了打字机的效果。

python streaming_call.py

4.2 流式处理的关键点与常见坑

1. 连接超时 ：流式响应可能持续较长时间，务必在请求中设置较长的 timeout （如 60 秒或更长），并做好连接中断的重试逻辑。
2. 数据格式解析 ：流式响应是多个 SSE 事件。每行以 data: 开头，后面跟着一个 JSON 对象或 [DONE] 。必须精确地剥离前缀并解析 JSON。 不同厂商的 SSE 格式可能有细微差别 ，例如空格、换行符或事件名称，需要根据实际响应调整解析逻辑。上述 Qwen 的解析器是一个示例，实际使用时请务必对照官方流式接口文档进行测试和调整。
3. 缓冲区与性能 ：对于极长的流式响应，在内存中拼接完整字符串（ full_content ）可能不是最佳选择。在生产环境中，应考虑边接收边处理（如写入文件、分块发送给前端等）。
4. 错误处理 ：流式过程中网络可能中断。代码需要捕获 requests.exceptions.ChunkedEncodingError 等异常，并实现重试或优雅降级。

5. 构建一个简单的模型切换代理

为了在实际项目中灵活切换模型，我们可以设计一个简单的代理层。这有助于将模型特定的细节封装起来，使业务逻辑保持干净。

5.1 代理类实现

创建文件 model_proxy.py ：

# model_proxy.py
import os
import json
import requests
from enum import Enum
from typing import List, Dict, Any, Optional, Generator
from dotenv import load_dotenv

load_dotenv()

class ModelProvider(Enum):
    """模型提供商枚举"""
    DEEPSEEK = "deepseek"
    QWEN = "qwen"
    # 未来可以扩展 OPENAI, CLAUDE 等

class AIModelProxy:
    """AI 模型代理，统一不同提供商的调用接口"""
    
    def __init__(self, provider: ModelProvider, model_name: str = None):
        self.provider = provider
        self.model_name = model_name or self._get_default_model(provider)
        self.api_key = self._get_api_key(provider)
        self.base_urls = {
            ModelProvider.DEEPSEEK: "https://api.deepseek.com",
            ModelProvider.QWEN: "https://dashscope.aliyuncs.com",
        }
    
    def _get_default_model(self, provider: ModelProvider) -> str:
        """获取各提供商的默认模型"""
        defaults = {
            ModelProvider.DEEPSEEK: "deepseek-chat",
            ModelProvider.QWEN: "qwen-turbo",
        }
        return defaults.get(provider, "")
    
    def _get_api_key(self, provider: ModelProvider) -> str:
        """从环境变量获取 API 密钥"""
        env_map = {
            ModelProvider.DEEPSEEK: "DEEPSEEK_API_KEY",
            ModelProvider.QWEN: "QWEN_API_KEY",
        }
        key_name = env_map.get(provider)
        if not key_name:
            raise ValueError(f"未配置提供商 {provider} 的环境变量映射")
        api_key = os.getenv(key_name)
        if not api_key:
            raise ValueError(f"请设置环境变量 {key_name}")
        return api_key
    
    def create_chat_completion(
        self,
        messages: List[Dict[str, str]],
        temperature: float = 0.7,
        max_tokens: Optional[int] = None,
        stream: bool = False
    ) -> Any:
        """
        创建聊天补全，返回原始响应数据。
        如果 stream=True，返回一个生成器 (Generator)。
        """
        if self.provider == ModelProvider.DEEPSEEK:
            return self._call_deepseek(messages, temperature, max_tokens, stream)
        elif self.provider == ModelProvider.QWEN:
            return self._call_qwen(messages, temperature, max_tokens, stream)
        else:
            raise NotImplementedError(f"提供商 {self.provider} 尚未实现")
    
    def _call_deepseek(self, messages, temperature, max_tokens, stream):
        """调用 DeepSeek API"""
        url = f"{self.base_urls[ModelProvider.DEEPSEEK]}/chat/completions"
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        payload = {
            "model": self.model_name,
            "messages": messages,
            "temperature": temperature,
            "stream": stream
        }
        if max_tokens:
            payload["max_tokens"] = max_tokens
        
        response = requests.post(url, headers=headers, json=payload, stream=stream, timeout=60 if stream else 30)
        response.raise_for_status()
        
        if stream:
            return self._handle_deepseek_stream(response)
        else:
            return response.json()
    
    def _handle_deepseek_stream(self, response) -> Generator[str, None, None]:
        """处理 DeepSeek 流式响应"""
        for line in response.iter_lines():
            if line:
                line_decoded = line.decode('utf-8')
                if line_decoded.startswith('data: '):
                    data_str = line_decoded[6:]
                    if data_str == '[DONE]':
                        break
                    try:
                        data = json.loads(data_str)
                        delta = data.get('choices', [{}])[0].get('delta', {})
                        content = delta.get('content', '')
                        if content:
                            yield content
                    except json.JSONDecodeError:
                        continue
    
    def _call_qwen(self, messages, temperature, max_tokens, stream):
        """调用 Qwen (DashScope) API"""
        url = f"{self.base_urls[ModelProvider.QWEN]}/api/v1/services/aigc/text-generation/generation"
        headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {self.api_key}"
        }
        payload = {
            "model": self.model_name,
            "input": {
                "messages": messages
            },
            "parameters": {
                "temperature": temperature,
                "result_format": "message"
            }
        }
        if max_tokens:
            payload["parameters"]["max_tokens"] = max_tokens
        if stream:
            payload["stream"] = True
        
        response = requests.post(url, headers=headers, json=payload, stream=stream, timeout=60 if stream else 30)
        response.raise_for_status()
        
        if stream:
            return self._handle_qwen_stream(response)
        else:
            return response.json()
    
    def _handle_qwen_stream(self, response) -> Generator[str, None, None]:
        """处理 Qwen 流式响应 (示例，需根据实际响应结构调整)"""
        for line in response.iter_lines():
            if line:
                line_decoded = line.decode('utf-8').strip()
                if line_decoded.startswith('data:'):
                    data_str = line_decoded[5:].strip()
                else:
                    data_str = line_decoded
                if not data_str or data_str == '[DONE]':
                    continue
                try:
                    data = json.loads(data_str)
                    # 重要：此处解析逻辑需要根据 DashScope 实际流式返回格式调整
                    # 可能是 data['output']['choices'][0]['message']['content']
                    # 也可能是其他路径，请以官方文档为准
                    content = data.get('output', {}).get('choices', [{}])[0].get('message', {}).get('content', '')
                    if content:
                        yield content
                except json.JSONDecodeError:
                    continue
    
    @staticmethod
    def extract_content(response_data, provider: ModelProvider) -> str:
        """从响应数据中提取文本内容 (非流式)"""
        if provider == ModelProvider.DEEPSEEK:
            return response_data.get('choices', [{}])[0].get('message', {}).get('content', '')
        elif provider == ModelProvider.QWEN:
            return response_data.get('output', {}).get('choices', [{}])[0].get('message', {}).get('content', '')
        else:
            raise NotImplementedError(f"提供商 {provider} 的内容提取尚未实现")

# 使用示例
if __name__ == "__main__":
    # 1. 使用 DeepSeek
    print("使用 DeepSeek 进行非流式调用:")
    deepseek_proxy = AIModelProxy(ModelProvider.DEEPSEEK, model_name="deepseek-chat")
    messages = [{"role": "user", "content": "你好，请介绍一下你自己。"}]
    response = deepseek_proxy.create_chat_completion(messages, stream=False)
    content = AIModelProxy.extract_content(response, ModelProvider.DEEPSEEK)
    print(f"DeepSeek 回复: {content[:100]}...\n")  # 打印前100字符
    
    # 2. 使用 Qwen 进行流式调用
    print("使用 Qwen 进行流式调用:")
    qwen_proxy = AIModelProxy(ModelProvider.QWEN, model_name="qwen-turbo")
    print("Qwen 回复: ", end="", flush=True)
    stream_gen = qwen_proxy.create_chat_completion(messages, stream=True)
    full_response = []
    for chunk in stream_gen:
        print(chunk, end="", flush=True)
        full_response.append(chunk)
    print(f"\n\n流式接收完成，总长度: {len(''.join(full_response))}")

这个代理类将不同模型的 API 细节隐藏起来，对外提供统一的 create_chat_completion 接口。业务代码只需关心提供商和模型名称，而无需处理具体的 URL 和响应解析。

6. 生产环境注意事项与常见问题排查

将原型代码迁移到生产环境，需要考虑更多稳定性、安全性和可维护性问题。

6.1 生产环境配置清单

6.2 常见错误与排查路径

在迁移和集成过程中，你可能会遇到以下典型问题：

6.3 性能与成本优化建议

1. 缓存策略 ：对于常见、重复的查询（如固定的系统提示词、常见问答），可以考虑在应用层增加缓存，减少对 API 的调用和 token 消耗。
2. 上下文管理 ：利用国产模型支持超长上下文的优势，可以一次性携带更多历史信息。但同时需注意，更长的上下文意味着更高的 token 成本和可能的处理延迟。需要根据场景权衡，必要时可对历史对话进行摘要（Summarization）。
3. 模型选型 ：并非所有任务都需要最强大的模型。例如，简单的文本分类或格式化任务，使用 qwen-turbo 或 deepseek-chat 可能比 qwen-max 成本更低、速度更快。建立模型性能与成本的评估体系。
4. Token 估算 ：在发送请求前，可以粗略估算输入的 tokens 数量（例如，中文按 2 tokens/字估算），避免因超出上下文限制而导致请求失败。各平台未来可能会提供官方的分词估算工具。

7. 扩展方向与下一步

完成基础迁移后，你可以根据项目需求向更深处探索：

1. 函数调用 (Function Calling) ：许多国产模型也支持类似 OpenAI 的函数调用功能，用于将自然语言转换为结构化 API 调用。查阅 DeepSeek 和 DashScope 的文档，了解其具体的实现方式。
2. 微调 (Fine-tuning) ：如果通用模型在特定领域表现不佳，可以考虑使用平台提供的微调服务，用你自己的数据训练一个专属模型。这需要准备训练数据集并了解相关流程和成本。
3. 多模态能力 ：一些国产模型已支持图像、文档等多模态输入。如果你的应用场景需要“看图说话”或分析文档，可以探索相关 API。
4. 集成官方 SDK ：本文使用 requests 是为了清晰展示底层过程。在生产中，强烈建议使用各平台的官方 Python SDK（如 dashscope 库），它们通常封装了更完善的错误处理、重试和工具函数。
5. 构建评估体系 ：迁移后，需要系统性地评估新模型在准确性、延迟、成本等维度上的表现。设计一套包含典型用例的测试集，定期运行，为模型选型和优化提供数据支持。

迁移的本质是在变化中寻找不变。虽然 API 的细节各异，但大语言模型应用的核心架构——提示词工程、上下文管理、流式处理、错误恢复——是相通的。通过本文的指南，你不仅能够完成从 Codex 到 DeepSeek 或 Qwen 的技术切换，更能建立起一套应对未来模型迭代和供应商变化的通用适配能力。

🚀 30+款热门AI模型一站整合，DeepSeek/GLM/Qwen 随心用，限时 5 折。 👉 点击领海量免费额度