你是不是也遇到过这样的情况：想用大模型做个智能助手、写个代码生成器，或者给自己的应用加点AI能力，但一看到“API调用”、“模型部署”、“Token计费”这些词就头大？网上教程要么是官方文档的简单翻译，要么是零散的代码片段，真正从零开始、能跑通、能避坑的保姆级指南少之又少。

别担心，这篇文章就是为你准备的。我将用30分钟，手把手带你从零开始，用Python完成一次完整的大模型API调用。这不仅仅是写几行代码，更重要的是让你理解背后的逻辑：为什么需要API Key？如何构造一个有效的请求？返回的JSON数据怎么处理？遇到“余额不足”、“连接中断”这些常见错误又该如何应对？

读完本文，你将能独立完成以下任务：

1. 快速搭建一个可用的Python开发环境。
2. 申请并配置主流大模型平台（如DeepSeek、智谱AI）的API Key。
3. 编写一个健壮的Python脚本，成功调用大模型API并获取回复。
4. 处理常见的API错误，并理解其背后的原因。
5. 将API调用封装成函数，方便在自己的项目中复用。

我们直接开始，跳过所有不必要的铺垫。

1. 核心问题：为什么你需要学会调用大模型API？

在深入代码之前，我们先明确一个核心判断： 学会调用大模型API，是当前将AI能力集成到自身应用中最直接、最高效的方式，没有之一。

这背后有三个关键原因：

第一，成本与效率的平衡。 自己训练或微调一个大模型，动辄需要数十张GPU和数月时间，成本高昂。而通过API调用，你只需按使用量付费（通常是按Token计费），瞬间就能获得顶尖模型的能力。这相当于用“租用超级计算机”的成本，享受了“拥有超级计算机”的算力。

第二，工程复杂度的极大降低。 模型部署、服务维护、算力调度、并发处理……这些底层工程问题都由API提供商解决了。作为开发者，你的关注点可以完全放在业务逻辑和应用创新上。你不需要成为AI基础设施专家，也能做出智能应用。

第三，快速迭代与选型自由。 今天用A模型的API写摘要，明天发现B模型的代码生成能力更强，切换可能只需要修改一行代码中的模型名称和API端点。这种灵活性让你能快速试验，为不同任务选择最合适的模型。

所以，无论你是想开发一个智能客服、一个代码补全插件，还是一个AI辅助写作工具，掌握API调用都是你必须跨过的第一道门槛。接下来，我们从最基础的环境准备开始。

2. 环境准备：三件套与虚拟环境

工欲善其事，必先利其器。一个干净、隔离的Python环境是成功的第一步，它能避免令人头疼的包版本冲突。

2.1 基础三件套安装

确保你的电脑上已经安装了以下软件：

1. Python (3.8或更高版本) ：大模型相关的库通常需要较新的Python版本。
2. pip (Python包管理工具) ：通常随Python一起安装。
3. 一个代码编辑器或IDE ：如VSCode、PyCharm，甚至记事本都可以，但推荐使用VSCode或PyCharm以获得更好的代码提示和调试体验。

打开你的终端（Windows上是CMD或PowerShell，Mac/Linux上是Terminal），输入以下命令检查安装情况：

python --version
# 或 python3 --version
pip --version
# 或 pip3 --version

如果能看到版本号（如 Python 3.10.12 ），说明安装成功。

2.2 创建并激活虚拟环境

强烈建议为这个项目创建一个独立的虚拟环境。这就像为你的项目建立一个“无菌实验室”，里面的所有依赖都是独立的，不会影响系统或其他项目。

# 1. 安装虚拟环境管理工具（如果尚未安装）
pip install virtualenv

# 2. 为你的项目创建一个新目录并进入
mkdir my_ai_project
cd my_ai_project

# 3. 创建虚拟环境，环境文件夹名为 `venv`
python -m venv venv

# 4. 激活虚拟环境
# 在 Windows 上：
venv\Scripts\activate
# 在 Mac/Linux 上：
source venv/bin/activate

激活后，你的命令行提示符前通常会显示 (venv) ，表示你已进入虚拟环境。 后续所有操作都在这个激活的虚拟环境中进行。

3. 核心概念：API、Key、Token与模型

写代码前，先花2分钟理解四个核心概念，这能帮你避开90%的初级错误。

• API (Application Programming Interface) ：可以理解为大模型服务商为你开的一个“窗口”。你通过这个窗口，按照规定的格式（比如发送一个HTTP请求）把问题（提示词）递进去，模型在内部处理完后，再把答案通过这个窗口递出来给你。你不需要知道模型内部有多复杂，只需要学会怎么“递纸条”和“接纸条”。
• API Key (密钥) ：这是你的“身份凭证”和“付款码”。每次调用API时都必须带上它，服务商通过它来识别你是谁，并从你的账户扣费。 务必像保管密码一样保管好它，不要泄露到公开代码库（如GitHub）中。
• Token (令牌) ：大模型处理文本的基本单位。在英文中，一个单词通常被切分成一个或几个Token；在中文中，一个汉字通常就是一个Token。API的计费通常与输入和输出总共消耗的Token数量直接相关。简单理解： 你发送的文字和模型回复的文字，加起来的总“字数”（按Token算）决定了这次调用的费用。
• 模型名称 (Model Name) ：指定你要使用哪个大模型。例如， deepseek-v4-flash （DeepSeek的快速模型）、 gpt-3.5-turbo （OpenAI）、 glm-4 （智谱GLM-4）。不同模型能力、价格、上下文长度（一次能处理多长的文本）都不同。

4. 第一步：获取你的API Key

没有Key，一切免谈。这里以国内开发者常用的 DeepSeek 和 智谱AI (GLM) 为例，演示如何获取。

DeepSeek API Key 获取步骤：

1. 访问 DeepSeek 开放平台官网（通常为 platform.deepseek.com）。
2. 注册并登录账号。
3. 在控制台或个人中心找到“API Keys”或“密钥管理” section。
4. 点击“创建新的API Key”，为其起个名字（如“my_first_project”）。
5. 立即复制生成的Key并妥善保存 。这个Key通常只显示一次，关闭页面后就看不到了。

智谱AI (GLM) API Key 获取步骤：

1. 访问智谱AI开放平台官网。
2. 同样完成注册登录。
3. 在控制台找到“API密钥”管理。
4. 申请或创建API Key。

重要安全提醒：

• 将API Key存储在环境变量中，是比直接写在代码里更安全的方式。
• 在本教程的示例中，为了清晰，我们会暂时将Key放在代码里，但 在实际项目中，请务必使用环境变量或配置文件 。

5. 安装必要的Python库

大模型API调用本质上是发送HTTP请求。我们可以用Python内置的 requests 库，但使用专为AI设计的第三方库（如 openai ，它兼容多个平台）会更方便，因为它帮你处理了请求格式、错误重试等琐事。

在你的虚拟环境（命令行前面有 (venv) ）中，执行以下安装命令：

pip install openai requests

这里安装了两个库：

• openai ：虽然名字叫“openai”，但这个库的架构设计得很好，通过修改“base_url”（API的基础地址），可以轻松兼容DeepSeek、智谱AI等提供OpenAI兼容接口的服务商。这是我们主要的工具。
• requests ：一个通用的、强大的HTTP库，作为备用或用于理解底层原理。

安装完成后，可以创建一个Python文件开始我们的编码之旅了。

6. 第一个API调用：向DeepSeek问好

让我们用最少的代码，完成一次成功的调用。创建一个名为 first_call.py 的文件。

6.1 代码实现

# first_call.py
import os
from openai import OpenAI

# 注意：此处仅为演示，实际应将API Key存储在环境变量中
# 例如：在终端执行 `export DEEPSEEK_API_KEY='your_key_here'` (Mac/Linux)
# 然后在代码中使用：api_key = os.getenv("DEEPSEEK_API_KEY")
DEEPSEEK_API_KEY = "your_deepseek_api_key_here"  # 请替换成你的真实Key

# 1. 初始化客户端
# 关键点：通过指定 `base_url` 和 `api_key`，我们将通用的 `OpenAI` 客户端指向了DeepSeek的服务。
client = OpenAI(
    api_key=DEEPSEEK_API_KEY,
    base_url="https://api.deepseek.com"  # DeepSeek的API端点
)

# 2. 构造请求并调用
try:
    response = client.chat.completions.create(
        model="deepseek-chat",  # 指定使用的模型，这里用DeepSeek的通用聊天模型
        messages=[
            {"role": "system", "content": "你是一个乐于助人的助手。"},  # 系统指令，设定AI的角色
            {"role": "user", "content": "你好，请用Python写一个简单的Hello World程序。"}  # 用户的问题
        ],
        stream=False,  # 非流式输出，一次性返回完整结果
        max_tokens=500  # 限制模型回复的最大Token数，控制成本和回复长度
    )
    
    # 3. 解析并打印结果
    # 响应体是一个复杂的对象，我们需要从中提取出我们需要的文本内容。
    ai_reply = response.choices[0].message.content
    print("AI回复：")
    print(ai_reply)
    print("\n--- 本次调用消耗信息 ---")
    print(f"输入Token数: {response.usage.prompt_tokens}")
    print(f"输出Token数: {response.usage.completion_tokens}")
    print(f"总Token数: {response.usage.total_tokens}")

except Exception as e:
    # 4. 异常处理
    print(f"调用API时出现错误: {e}")

6.2 代码逐行解析

1. 初始化客户端 ( client = OpenAI(...) ) : 这是最关键的一步。我们告诉 OpenAI 库，不要去找OpenAI的服务器，而是去找 base_url 指定的DeepSeek服务器，并且使用我们提供的 api_key 进行认证。
2. 构造请求 ( client.chat.completions.create ) : 这是调用聊天补全接口的标准方法。
   • model : 必须指定。 deepseek-chat 是DeepSeek提供的一个模型名称。
   • messages : 一个列表，定义了对话的历史和当前回合。每条消息都有 role （角色）和 content （内容）。 system 角色用于设定AI的全局行为指令， user 角色代表用户的输入。一个复杂的对话可以包含多轮 user 和 assistant （AI）的消息。
   • stream : 设为 False 表示我们想要一次性拿到完整回复。如果设为 True ，则会以流的形式逐步返回，适合需要实时显示的场景（如聊天界面），代码处理会稍复杂。
   • max_tokens : 设置回复的最大长度，这是一个重要的成本和安全控制参数。
3. 解析结果 : 响应对象 response 结构丰富。我们最关心的是 response.choices[0].message.content ，这就是AI返回的文本。 response.usage 里则包含了本次调用的Token消耗详情，对监控成本至关重要。
4. 异常处理 ( try...except ) : 网络问题、Key错误、额度不足、服务器异常等都可能导致调用失败。用 try...except 包裹核心调用代码是良好的编程习惯，能让你的程序更健壮。

6.3 运行与验证

在终端中，确保你在项目目录下且虚拟环境已激活，然后运行：

python first_call.py

预期成功输出： 你会先看到AI生成的Python “Hello World” 代码，然后看到本次调用的Token消耗统计。

AI回复：
```python
print("Hello, World!")

...

--- 本次调用消耗信息 --- 输入Token数: 25 输出Token数: 12 总Token数: 37

**如果运行失败，请按以下顺序排查：**
1.  **API Key错误**: 检查 `DEEPSEEK_API_KEY` 变量中的字符串是否正确，是否包含了多余的空格或换行。
2.  **网络连接问题**: 检查你的网络是否能正常访问 `https://api.deepseek.com`。
3.  **库未安装**: 确认是否在正确的虚拟环境中执行了 `pip install openai`。
4.  **额度不足**: 前往DeepSeek控制台，检查API调用余额或套餐是否有效。

## 7. 进阶：调用智谱GLM API并处理流式响应

掌握了基础调用后，我们尝试另一个主流平台——智谱AI，并学习如何处理更高效的**流式响应**。

### 7.1 代码实现：流式调用GLM-4

创建一个新文件 `stream_call_glm.py`。

```python
# stream_call_glm.py
import os
from openai import OpenAI

# 替换为你的智谱AI API Key
ZHIPU_API_KEY = "your_zhipu_api_key_here"  # 请替换

# 初始化指向智谱AI的客户端
client = OpenAI(
    api_key=ZHIPU_API_KEY,
    base_url="https://open.bigmodel.cn/api/paas/v4/",  # 智谱AI的V4 API端点
)

# 这次我们使用流式响应
try:
    print("AI正在思考...（流式输出）")
    stream = client.chat.completions.create(
        model="glm-4-flash",  # 使用智谱的GLM-4-Flash模型，响应速度快
        messages=[
            {"role": "user", "content": "用简单的语言解释一下什么是机器学习？"}
        ],
        stream=True,  # 关键参数：启用流式输出
        max_tokens=300,
    )

    collected_content = []
    print("回复：", end="", flush=True)
    
    # 迭代处理流中的每一个片段（chunk）
    for chunk in stream:
        # 每个chunk中可能包含回复内容的增量(delta)
        if chunk.choices[0].delta.content is not None:
            content_piece = chunk.choices[0].delta.content
            print(content_piece, end="", flush=True)  # 逐片打印，不换行
            collected_content.append(content_piece)
    
    full_reply = "".join(collected_content)
    print(f"\n\n--- 完整回复已接收，总字数约 {len(full_reply)} 字 ---")

except Exception as e:
    print(f"\n调用过程中发生错误: {e}")

7.2 流式与非流式的核心区别

• 非流式 (stream=False) ：就像发一封邮件。你把问题写好寄出去，然后等待。服务器端模型完全生成好所有回答后，打包成一封完整的回信寄给你。你收到信时，内容已经全部在了。 优点 是代码简单，拿到的是完整对象。 缺点 是对于长回答，用户需要等待较长时间才能看到任何内容。
• 流式 (stream=True) ：就像打电话。你一边说，对方一边听一边思考并开始回答。对方的回答是逐字逐句传过来的，你可以实时听到。在代码中，这表现为一个可迭代的“流”（stream），你从中不断读取到内容片段（chunk）。 优点 是用户体验好，响应感知延迟低。 缺点 是代码处理稍复杂，且响应对象的结构与一次性返回不同（没有完整的 usage 信息，直到流结束）。

何时使用流式？ 当你在构建需要实时交互的应用时，例如聊天机器人、代码实时补全界面等。

8. 封装与复用：构建你自己的AI工具函数

每次都写一遍初始化、构造消息、异常处理太麻烦了。一个好的实践是将核心功能封装成函数，方便在不同项目中调用。

8.1 创建可配置的AI调用模块

创建一个文件 ai_helper.py ，我们将它打造成一个实用的工具模块。

# ai_helper.py
import os
from typing import List, Dict, Optional, Generator
from openai import OpenAI, OpenAIError

class AIClient:
    """
    一个通用的AI API调用客户端封装类。
    支持配置不同的平台（通过base_url）和模型。
    """
    
    def __init__(self, api_key: str, base_url: str, default_model: str):
        """
        初始化客户端。
        
        :param api_key: 你的API密钥
        :param base_url: API服务的基础URL，如 "https://api.deepseek.com"
        :param default_model: 默认使用的模型名称，如 "deepseek-chat"
        """
        if not api_key:
            raise ValueError("API Key 不能为空")
        self.client = OpenAI(api_key=api_key, base_url=base_url)
        self.default_model = default_model
        
    def chat(self, 
             prompt: str, 
             system_prompt: Optional[str] = "你是一个有帮助的助手。",
             model: Optional[str] = None,
             max_tokens: int = 1000,
             temperature: float = 0.7,
             stream: bool = False) -> Optional[str]:
        """
        发送聊天请求并获取回复。
        
        :param prompt: 用户输入的问题或指令
        :param system_prompt: 系统指令，用于设定AI角色
        :param model: 使用的模型，为None则使用默认模型
        :param max_tokens: 回复的最大token数
        :param temperature: 采样温度(0-2)，值越高回复越随机创造性，越低越确定保守
        :param stream: 是否使用流式输出
        :return: 如果stream=False，返回完整的回复文本；如果stream=True，返回一个生成器。
        :raises: 可能抛出OpenAIError或网络相关异常
        """
        target_model = model or self.default_model
        messages = []
        if system_prompt:
            messages.append({"role": "system", "content": system_prompt})
        messages.append({"role": "user", "content": prompt})
        
        try:
            if stream:
                # 流式响应返回一个生成器
                response_stream = self.client.chat.completions.create(
                    model=target_model,
                    messages=messages,
                    max_tokens=max_tokens,
                    temperature=temperature,
                    stream=True
                )
                return self._handle_stream_response(response_stream)
            else:
                # 非流式响应直接返回文本
                response = self.client.chat.completions.create(
                    model=target_model,
                    messages=messages,
                    max_tokens=max_tokens,
                    temperature=temperature,
                    stream=False
                )
                return response.choices[0].message.content
                
        except OpenAIError as e:
            # 这里可以更精细地处理不同类型的API错误，如认证失败、额度不足、上下文过长等
            print(f"AI API调用错误: {e}")
            raise
        except Exception as e:
            print(f"未知错误: {e}")
            raise
    
    def _handle_stream_response(self, stream) -> Generator[str, None, None]:
        """处理流式响应，逐块生成内容。"""
        for chunk in stream:
            if chunk.choices[0].delta.content is not None:
                yield chunk.choices[0].delta.content

# 示例：创建针对DeepSeek的客户端配置
def create_deepseek_client(api_key: str):
    """快速创建一个配置好的DeepSeek客户端。"""
    return AIClient(
        api_key=api_key,
        base_url="https://api.deepseek.com",
        default_model="deepseek-chat"
    )

# 示例：创建针对智谱GLM的客户端配置
def create_zhipu_client(api_key: str):
    """快速创建一个配置好的智谱GLM客户端。"""
    return AIClient(
        api_key=api_key,
        base_url="https://open.bigmodel.cn/api/paas/v4/",
        default_model="glm-4-flash"
    )

8.2 使用封装的工具

现在，在你的主程序文件中，调用AI变得非常简单和清晰。创建一个 main.py 文件：

# main.py
from ai_helper import create_deepseek_client, create_zhipu_client
import os

# 从环境变量读取API Key是更安全的方式
DEEPSEEK_KEY = os.getenv("DEEPSEEK_API_KEY", "your_key_here") # 优先从环境变量获取
ZHIPU_KEY = os.getenv("ZHIPU_API_KEY", "your_key_here")

def test_deepseek():
    print("=== 测试 DeepSeek ===")
    client = create_deepseek_client(DEEPSEEK_KEY)
    reply = client.chat(
        prompt="用一句话总结Python的优点。",
        system_prompt="你是一个资深的Python开发者。",
        max_tokens=100
    )
    print(f"DeepSeek 回复: {reply}")

def test_zhipu_stream():
    print("\n=== 测试智谱GLM (流式) ===")
    client = create_zhipu_client(ZHIPU_KEY)
    print("AI回复（流式）: ", end="", flush=True)
    
    # 注意：流式调用返回的是一个生成器
    reply_generator = client.chat(
        prompt="写一首关于编程的短诗。",
        stream=True
    )
    
    full_reply = ""
    for chunk in reply_generator:
        print(chunk, end="", flush=True)
        full_reply += chunk
    print(f"\n\n(流式接收完成)")

if __name__ == "__main__":
    # 你可以选择性地测试
    test_deepseek()
    # test_zhipu_stream()

通过这种封装，你获得了：

• 代码复用性 ：在项目的任何地方，导入 ai_helper 就能用。
• 可维护性 ：所有API配置和调用逻辑集中在一处，修改平台或模型参数很容易。
• 灵活性 ：轻松切换不同的AI服务提供商。
• 健壮性 ：统一的错误处理。

9. 你必须避开的“坑”：常见错误与排查指南

调用API时，你几乎一定会遇到错误。以下是新手最常踩的坑及其解决方法。

问题现象	可能原因	排查方式	解决方案
APIError: 401	认证失败。	检查错误信息是否包含“Incorrect API key”或“invalid authentication”。	1. 确认API Key完全正确，没有多余空格。 2. 确认Key所属的平台（DeepSeek/智谱等）与代码中 base_url 匹配。 3. 确认Key是否有调用权限或是否已启用。
APIError: 429	请求频率超限或配额不足。	错误信息通常为“Rate limit exceeded”或“Quota exceeded”。	1. 检查控制台，确认是否达到每分钟/每天请求次数限制。 2. 检查API余额或套餐是否耗尽。 3. 降低调用频率，或升级套餐。
APIError: 400	请求格式错误或参数无效。	错误信息可能提示“Invalid model”、“max_tokens too large”或“messages format error”。	1. 检查 model 参数名称是否拼写正确，是否是该平台支持的模型。 2. 检查 max_tokens 是否超过模型允许的最大值。 3. 检查 messages 列表格式是否正确，角色是否为 system / user / assistant 。
APIError: 500 或 503	服务器内部错误或服务不可用。	通常是服务商端的问题。	1. 等待几分钟后重试。 2. 查看服务商的状态页面（如果有）。 3. 如果持续发生，可能是你的请求触发了某些内部错误，尝试简化请求内容。
ConnectionError 或超时	网络连接问题。	检查本地网络，尝试ping API的域名。	1. 检查本地防火墙或代理设置。 2. 如果使用公司网络，可能存在对外部API的访问限制。 3. 尝试增加请求超时时间（在客户端初始化时配置）。
回复内容乱码或截断	编码问题或 max_tokens 设置过小。	观察回复末尾是否不完整。	1. 确保Python文件和终端使用UTF-8编码。 2. 适当增加 max_tokens 参数的值。注意：这会增加单次调用成本和耗时。
流式响应不完整或中断	网络不稳定或流处理逻辑有误。	检查是否在循环读取流时发生异常。	1. 增强网络稳定性。 2. 在流式处理的循环外添加更全面的异常捕获。 3. 考虑加入重试逻辑（对于非关键任务）。

一个重要的参数： temperature 在上面的封装类中，我们引入了 temperature 参数。它控制输出的随机性：

• temperature=0 ：模型每次都会对同一个提示给出确定性最高、最保守的答案。
• temperature=0.7 （常用默认值）：在创造性和稳定性之间取得平衡。
• temperature=1.0 或更高：输出会非常多样化和有创意，但也可能偏离主题或产生“幻觉”。 建议 ：对于需要事实准确性的任务（如问答、总结），使用较低的温度（0.1-0.3）。对于创意任务（如写诗、生成故事），可以使用较高的温度（0.7-1.0）。

10. 最佳实践与工程化建议

当你准备将API调用集成到真实项目中时，请遵循以下建议：

1. 密钥管理绝对不要硬编码 ：永远不要将API Key直接写在源代码中并提交到Git等版本控制系统。必须使用环境变量或安全的配置管理服务。

   • 本地开发 ：在项目根目录创建 .env 文件（并加入 .gitignore ），使用 python-dotenv 库读取。

     # .env 文件内容
     DEEPSEEK_API_KEY=sk-your-actual-key-here
     ZHIPU_API_KEY=your-zhipu-key-here
     

     # 在Python中读取
     from dotenv import load_dotenv
     load_dotenv()
     api_key = os.getenv("DEEPSEEK_API_KEY")
     

   • 服务器部署 ：使用云服务商提供的密钥管理服务（如AWS Secrets Manager, Azure Key Vault）或环境变量配置。

2. 实施速率限制与重试 ：API服务商都有调用频率限制。在你的客户端封装中加入简单的限流和指数退避重试逻辑，可以提升程序稳定性。

   import time
   from tenacity import retry, stop_after_attempt, wait_exponential
   
   class RobustAIClient(AIClient):
       @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
       def chat_with_retry(self, prompt, **kwargs):
           """带重试机制的聊天调用"""
           return self.chat(prompt, **kwargs)
   

   （使用前需安装 pip install tenacity ）

3. 记录与监控 ：记录每次调用的时间、消耗的Token数、模型名称和是否成功。这对于成本核算、性能分析和故障排查至关重要。可以简单地写入日志文件，或发送到监控系统。

4. 设置合理的超时与上下文长度 ：根据你的应用场景，在客户端初始化时设置合理的超时时间（如 timeout=30.0 ）。同时，了解你所使用模型的 上下文窗口长度 （例如4096, 8192, 128K tokens），确保你发送的 messages 总长度不超过这个限制，否则会收到 400 错误。

5. 进行输入验证与清理 ：对用户输入的 prompt 进行基本的清理和长度检查，防止注入攻击或意外触发长文本处理导致的高费用。

6. 为生产环境准备降级方案 ：如果你的应用严重依赖某个AI服务，考虑集成多个服务商作为备份，或者当主要服务不可用时，有非AI的备选逻辑，保证核心功能可用。

从在终端里运行第一行 pip install 命令，到构建出一个健壮、可配置、可复用的AI工具类，你已经走完了从零到一的关键步骤。这个过程的核心不是记忆代码，而是理解“请求-响应”这个基本范式，以及如何围绕它处理认证、参数、错误和性能。

接下来，你可以基于这个基础做很多事情：用Flask或FastAPI快速搭建一个AI对话的Web服务；将AI总结能力接入你的文档处理流水线；甚至结合LangChain等框架，构建更复杂的AI智能体。真正的旅程，现在才刚刚开始。建议你将本文中的 ai_helper.py 模块保存下来，它将成为你未来许多AI小项目的得力起点。如果在实践中遇到新的问题，回头来查查“常见问题”部分，或许就能找到答案。