← 返回上一页

第4章: 大模型API调用实战:鉴权、重试、流式与成本控制

调用大模型API,构建智能应用

🚀 掌握大模型调用技术,开启AI应用开发新篇章

🤔 使用大模型的两种方式

在开始之前,你需要了解使用大模型有两种主要方式。理解它们的区别,可以帮助你选择最适合自己的方案。

📊 两种方式的工作原理对比

方式一:云端 API 你的电脑 只需发请求 云端服务器 大模型在此运行 互联网 ✅ 电脑配置无所谓 ✅ 模型能力最强 ❌ 必须联网使用 方式二:本地部署 模型文件 你的电脑 直接运行模型 ❌ 电脑越强越好 ❌ 模型能力受限 ✅ 断网也能用
☁️

方式一:云端API

调用别人部署好的模型

✨ 优点

  • 即开即用:注册账号即可使用,无需安装
  • 性能强大:使用最先进的大型模型
  • 速度快:专业服务器,响应迅速
  • 无硬件要求:任何电脑都能用
  • 持续更新:模型自动升级优化

⚠️ 缺点

  • 需要付费:按使用量计费(有免费额度)
  • 需要网络:必须联网才能使用
  • 数据上传:你的问题会发送到服务器
💡 适合场景:

生产环境、商业项目、需要高质量输出、团队协作

👉 本章重点:

我们主要讲解这种方式,因为它最简单、最实用!

🖥️

方式二:本地部署

在自己电脑上运行模型

✨ 优点

  • 完全免费:开源模型,无使用限制
  • 离线可用:不需要网络连接
  • 数据私密:所有数据在本地,不上传
  • 完全控制:可以自定义和微调模型

⚠️ 缺点

  • 硬件要求高:至少需要 8GB 内存
  • 占用空间大:每个模型 3-20GB
  • 速度较慢:没有 GPU 会很慢
  • 能力有限:小模型不如商业大模型
  • 需要学习:安装配置有一定门槛
💡 适合场景:

学习研究、隐私要求高、离线环境、个人实验

📋 快速对比表

对比项 ☁️ 云端API 🖥️ 本地部署
上手难度 ⭐ 简单 ⭐⭐⭐ 中等
硬件要求 无要求 8GB+ 内存
使用成本 按量付费 免费
响应速度 快(1-3秒) 慢(5-30秒)
模型能力 强大 一般
数据隐私 上传到服务器 完全本地
推荐指数 ⭐⭐⭐⭐⭐ ⭐⭐⭐

💡 我们的建议

对于初学者和大多数场景,我们强烈推荐使用云端API:

  • ✅ 上手简单,5分钟就能开始使用
  • ✅ 模型能力强,输出质量高
  • ✅ 新用户有免费额度,足够学习使用
  • ✅ 适合实际项目开发

本地部署适合以下情况:

  • 🔒 对数据隐私要求极高
  • 🌐 需要在离线环境使用
  • 🔬 想深入研究模型原理
  • 💰 长期大量使用,想节省成本

📚 本章内容安排

我们将重点讲解云端API的使用(通义千问 & DeepSeek),因为这是最实用的方式。

同时,我们也会在最后介绍本地部署的方法(Ollama、LM Studio),供有需要的同学参考。

☁️ 云端API:使用国内大模型

🌏 为什么选择国内大模型?

🚀

无需翻墙

国内直接访问

国内服务器,网络延迟低,稳定性高,适合生产环境使用。

💰

价格便宜

性价比极高

相比国外服务,国内大模型价格更具优势,新用户还有免费额度。

🎁

免费额度

新用户福利

新用户可获得大量免费tokens,足够学习和测试使用。

🇨🇳

中文优化

理解更准确

专门针对中文语言和文化进行优化,理解语境更准确。

⚠️ 重要提示

本章介绍的是国内可直接访问的大模型API。如果你需要使用OpenAI的GPT模型,需要国际信用卡和科学上网工具。

📱 选择你的平台

我们推荐两个国内优秀的大模型平台,选择其中一个即可开始你的AI之旅:

🎯 平台选择指南

🔷

通义千问

阿里云出品,功能全面

  • ✅ 新用户100万免费tokens
  • ✅ 功能全面,支持多模态
  • ✅ 企业级服务,稳定可靠
  • ✅ 文档完善,社区活跃
推荐人群:

新手入门、企业应用

🔶

DeepSeek

深度求索,编程专家

  • ✅ 价格极其便宜
  • ✅ 编程能力超强
  • ✅ 数学推理优秀
  • ✅ 开源模型可选
推荐人群:

开发者、技术写作

💡 选择建议

如果你是新手:推荐通义千问,功能全面,文档完善,学习曲线平缓。
如果你是开发者:推荐DeepSeek,编程能力强,价格便宜,适合技术场景。
如果用于企业:推荐通义千问,阿里生态整合度高,服务更有保障。

🔷 通义千问(阿里云)
🔶 DeepSeek

🔷 通义千问 - 获取API Key详细步骤

🎁 新用户福利

新用户注册即可获得100万tokens免费额度,足够学习和测试使用!

1

访问阿里云官网

打开浏览器,访问:https://www.aliyun.com

💡 如果没有阿里云账号,点击右上角"免费注册"

2

进入通义千问控制台

登录后,访问:https://dashscope.console.aliyun.com

或者在阿里云首页搜索"通义千问",点击"管理控制台"

3

开通服务

首次使用需要开通服务:

  1. 点击"立即开通"按钮
  2. 阅读并同意服务协议
  3. 选择"按量付费"(新用户有免费额度)
  4. 点击"立即开通"完成
🎁 新用户福利:

新用户可获得100万tokens的免费额度,足够学习使用!

4

创建API Key

  1. 在控制台左侧菜单,点击"API-KEY管理"
  2. 点击"创建新的API-KEY"按钮
  3. 输入API Key名称(如:我的第一个Key)
  4. 点击"确定"
  5. ⚠️ 重要:立即复制并保存API Key!(只显示一次)

⚠️ 安全提示

  • API Key相当于密码,不要分享给他人
  • 不要将API Key提交到GitHub等公开平台
  • 建议使用环境变量存储API Key

🔧 配置环境变量(重要!)

获取API Key后,我们需要将它安全地存储在环境变量中。选择你的操作系统查看配置方法:

🪟 Windows
🍎 Mac
🐧 Linux
🐍 Python (.env)

方法1:图形界面(推荐新手)

  1. 右键"此电脑" → "属性" → "高级系统设置" → "环境变量"
  2. 在"用户变量"点击"新建"
  3. 变量名:DASHSCOPE_API_KEY
  4. 变量值:粘贴你的API Key
  5. 点击"确定",重新打开命令行窗口

方法2:命令行

text
# 永久设置
setx DASHSCOPE_API_KEY "your-api-key-here"

# 验证(需要重新打开CMD)
echo %DASHSCOPE_API_KEY%

配置步骤

text
# 1. 确定Shell类型
echo $SHELL

# 2. 编辑配置文件(zsh是Mac默认)
nano ~/.zshrc

# 3. 添加以下内容到文件末尾
export DASHSCOPE_API_KEY="your-api-key-here"

# 4. 保存(Ctrl+O)并退出(Ctrl+X)

# 5. 使配置生效
source ~/.zshrc

# 6. 验证
echo $DASHSCOPE_API_KEY

配置步骤

text
# 1. 编辑bash配置
nano ~/.bashrc

# 2. 添加以下内容
export DASHSCOPE_API_KEY="your-api-key-here"

# 3. 保存并使配置生效
source ~/.bashrc

# 4. 验证
echo $DASHSCOPE_API_KEY

使用.env文件(推荐!跨平台通用)

python
# 1. 安装依赖(根据Python版本选择)
pip3 install python-dotenv
# 或
pip install python-dotenv

# 2. 在项目根目录创建 .env 文件
DASHSCOPE_API_KEY=your-api-key-here

# 3. 在Python代码中加载
from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv('DASHSCOPE_API_KEY')

# 4. 添加到 .gitignore
echo ".env" >> .gitignore

� 核心参数详解(重要!)

在调用大模型API之前,先理解这些核心参数,它们决定了AI的输出质量和行为。

1️⃣ model - 模型选择

作用:选择使用哪个AI模型,不同模型有不同的能力和速度。

通义千问的模型:
  • qwen-turbo:速度最快,成本最低,适合简单对话
  • qwen-plus:平衡性能,适合大多数场景
  • qwen-max:能力最强,适合复杂任务

💡 建议:开发测试用turbo,生产环境用plus或max

2️⃣ messages - 对话消息

作用:定义对话的内容和上下文,是一个列表,包含多条消息。

三种角色(role):
  • system:系统消息,设定AI的角色和行为规则
    text
    {"role": "system", "content": "你是一个Python专家"}
  • user:用户消息,你的问题或指令
    text
    {"role": "user", "content": "如何学习Python?"}
  • assistant:AI的回复,用于多轮对话
    text
    {"role": "assistant", "content": "我建议从基础语法开始..."}

💡 技巧:system消息可以让AI扮演特定角色,如"专业翻译"、"代码审查员"等

3️⃣ temperature - 创造性控制

作用:控制AI输出的随机性和创造性,范围0.0-2.0。

0.0 - 0.3

最确定、最一致

✅ 适合:代码生成、翻译、数据提取

0.7 - 1.0

平衡创造性

✅ 适合:日常对话、问答

1.0 - 2.0

高度创造性

✅ 适合:创意写作、头脑风暴

💡 举例:temperature=0.1生成的代码每次都一样,temperature=1.5每次都有新创意

🔤 什么是Token?(重要概念)

Token 是AI模型理解和处理文本的基本单位,可以理解为"文本碎片"。AI不是直接读取文字,而是先把文字切分成tokens,然后再处理。

📊 Token切分示例
中文示例:
原文:
我爱学习Python编程
↓ 切分成tokens ↓
学习 Python 编程
✅ 共5个tokens(8个字符)
英文示例:
原文:
I love learning Python programming
↓ 切分成tokens ↓
I love learning Python programming
✅ 共5个tokens(5个单词)
代码示例:
原文:
def hello():
↓ 切分成tokens ↓
def hello ( ) :
✅ 共5个tokens(标点符号也算)
📐 Token换算规则
语言类型 换算比例 示例
中文 1 token ≈ 1.5个汉字 1000 tokens ≈ 600-700字
英文 1 token ≈ 0.75个单词 1000 tokens ≈ 750个单词
代码 1 token ≈ 1个符号 标点、括号都算token
💰 Token与费用的关系

大模型API按token计费,输入和输出都算!

计费示例:
你的问题:"用Python写一个Hello World" (约15 tokens)
AI的回答:一段代码和解释 (约200 tokens)
总消耗:15 + 200 = 215 tokens

4️⃣ max_tokens - 输出长度限制

作用:限制AI生成的最大token数量,避免输出过长或浪费费用。

推荐设置:
  • max_tokens=500 → 约300-350个中文字(简短回答)
  • max_tokens=1000 → 约600-700个中文字(普通对话)
  • max_tokens=2000 → 约1200-1400个中文字(长文章)
  • max_tokens=4000 → 约2400-2800个中文字(详细文档)
实际场景举例:
  • 问答机器人:max_tokens=500(回答简洁)
  • 代码生成:max_tokens=1500(包含注释和说明)
  • 文章写作:max_tokens=3000(完整文章)
  • 翻译任务:根据原文长度×1.5设置

⚠️ 注意:max_tokens设置太小会导致回答被截断(说到一半就停了),设置太大会增加费用和等待时间!

5️⃣ stream - 流式输出

作用:控制是逐字返回(像ChatGPT)还是一次性返回完整结果。

stream=True

逐字输出,用户体验好

✅ 适合:聊天应用、实时交互

stream=False

一次性返回,代码简单

✅ 适合:批量处理、API调用

6️⃣ 高级参数(可选)

  • top_p (0.1-1.0):核采样,与temperature类似,控制输出多样性,二选一使用
  • frequency_penalty (-2.0到2.0):频率惩罚,降低重复内容,值越大越不重复
  • presence_penalty (-2.0到2.0):存在惩罚,鼓励谈论新话题,避免重复主题

💡 建议:初学者可以先不用这些参数,使用默认值即可

� Python调用示例

📦 什么是 dashscope?

dashscope 是阿里云通义千问的官方Python SDK(软件开发工具包),专门用来调用通义千问的API。就像 requests 是用来发HTTP请求的库一样,dashscope 是用来调用通义千问的库。

1. 安装SDK

💡 根据你的Python版本选择命令:

text
# Python 3.x (推荐)
pip3 install dashscope

# 或者使用 pip(如果pip默认是Python 3)
pip install dashscope

# 如果有多个Python版本,指定版本
python3 -m pip install dashscope

💡 pip 拉包慢怎么办? 可以临时切换国内镜像源(推荐),或配置为默认源。

text
# 方式1:临时使用国内镜像(推荐)
pip install dashscope -i https://pypi.tuna.tsinghua.edu.cn/simple
# 或(阿里云镜像)
pip install dashscope -i https://mirrors.aliyun.com/pypi/simple/

# 方式2:增加超时/重试(网络抖动时有用)
pip install dashscope --timeout 120 --retries 5

# 方式3:永久配置默认镜像(macOS/Linux)
mkdir -p ~/.pip
cat > ~/.pip/pip.conf << 'EOF'
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
timeout = 120
EOF

# 方式3(Windows):永久配置默认镜像
# 方案A:直接写 pip.ini(推荐最直观)
# 位置:%APPDATA%\pip\pip.ini  (一般是:C:\Users\你的用户名\AppData\Roaming\pip\pip.ini)
mkdir %APPDATA%\pip
notepad %APPDATA%\pip\pip.ini

# 在 pip.ini 中写入:
[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
timeout = 120

# 方案B:使用 pip config(PowerShell/CMD 都可)
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
pip config set global.timeout 120

提示:如果你在公司网络/校园网环境,可能需要代理或切换网络;也可以先升级 pip:python3 -m pip install -U pip

2. 基础调用

python
import dashscope
from dashscope import Generation

# 设置API Key
dashscope.api_key = "your-api-key-here"

# 调用通义千问
response = Generation.call(
    model='qwen-turbo',  # 或 qwen-plus, qwen-max
    messages=[
        {'role': 'system', 'content': '你是一个helpful助手'},
        {'role': 'user', 'content': '什么是人工智能?'}
    ]
)

# 打印结果
print(response.output.text)

3. 流式输出

python
responses = Generation.call(
    model='qwen-turbo',
    messages=[{'role': 'user', 'content': '讲个故事'}],
    stream=True
)

for response in responses:
    if response.output.text:
        print(response.output.text, end='')

4. 完整示例(推荐)

python
import dashscope
from dashscope import Generation
import os

# 从环境变量读取API Key(更安全)
dashscope.api_key = os.getenv('DASHSCOPE_API_KEY')

def chat_with_qwen(user_message):
    """与通义千问对话"""
    response = Generation.call(
        model='qwen-turbo',  # 使用turbo模型
        messages=[
            {'role': 'system', 'content': '你是一个helpful助手'},
            {'role': 'user', 'content': user_message}
        ],
        temperature=0.7,     # 平衡的创造性
        max_tokens=1000      # 最多生成1000个token
    )
    
    if response.status_code == 200:
        return response.output.text
    else:
        return f"错误:{response.message}"

# 使用示例
result = chat_with_qwen("用Python写一个Hello World")
print(result)

🔶 DeepSeek - 获取API Key详细步骤

步骤1:访问DeepSeek官网

打开浏览器,访问:https://platform.deepseek.com

💡 提示:支持手机号注册,非常简单

步骤2:注册账号

  1. 点击右上角"注册"按钮
  2. 输入手机号
  3. 获取并输入验证码
  4. 设置密码(至少8位)
  5. 点击"注册"完成

步骤3:领取免费额度

登录后会自动跳转到控制台:

  1. 点击左侧"额度管理"
  2. 新用户可领取500万tokens免费额度
  3. 点击"领取"按钮
🎁 新用户福利:

500万tokens免费额度,价值约50元,够用很久!

步骤4:创建API Key

  1. 点击左侧"API Keys"菜单
  2. 点击"创建API Key"按钮
  3. 输入Key名称(如:学习用Key)
  4. 点击"创建"
  5. ⚠️ 重要:立即复制API Key!(只显示一次)

⚠️ 安全提示

  • API Key是你的身份凭证,妥善保管
  • 不要在代码中硬编码API Key
  • 使用环境变量或配置文件存储

🔧 配置环境变量(重要!)

获取API Key后,我们需要将它安全地存储在环境变量中。选择你的操作系统查看配置方法:

🪟 Windows
🍎 Mac
🐧 Linux
🐍 Python (.env)

方法1:图形界面(推荐新手)

  1. 右键"此电脑" → "属性" → "高级系统设置" → "环境变量"
  2. 在"用户变量"点击"新建"
  3. 变量名:DEEPSEEK_API_KEY
  4. 变量值:粘贴你的API Key
  5. 点击"确定",重新打开命令行窗口

方法2:命令行

text
# 永久设置
setx DEEPSEEK_API_KEY "your-api-key-here"

# 验证(需要重新打开CMD)
echo %DEEPSEEK_API_KEY%

配置步骤

text
# 1. 确定Shell类型
echo $SHELL

# 2. 编辑配置文件(zsh是Mac默认)
nano ~/.zshrc

# 3. 添加以下内容到文件末尾
export DEEPSEEK_API_KEY="your-api-key-here"

# 4. 保存(Ctrl+O)并退出(Ctrl+X)

# 5. 使配置生效
source ~/.zshrc

# 6. 验证
echo $DEEPSEEK_API_KEY

配置步骤

text
# 1. 编辑bash配置
nano ~/.bashrc

# 2. 添加以下内容
export DEEPSEEK_API_KEY="your-api-key-here"

# 3. 保存并使配置生效
source ~/.bashrc

# 4. 验证
echo $DEEPSEEK_API_KEY

使用.env文件(推荐!跨平台通用)

python
# 1. 安装依赖(根据Python版本选择)
pip3 install python-dotenv
# 或
pip install python-dotenv

# 2. 在项目根目录创建 .env 文件
DEEPSEEK_API_KEY=your-api-key-here

# 3. 在Python代码中加载
from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv('DEEPSEEK_API_KEY')

# 4. 添加到 .gitignore
echo ".env" >> .gitignore

⚙️ 重要参数说明

了解这些关键参数,让你更好地控制AI的输出效果:

🎛️ 参数调优指南

🌡️

temperature

控制输出的随机性

0.0-0.3 更确定、更一致
0.7-1.2 更有创造性(聊天/文案常用)
1.2-2.0 高随机性(脑暴/创意,需注意跑题)
默认值 0.7
取值范围 常见为0.0-2.0(不同模型可能不同,以模型文档为准)

💡 编程/抽取建议用0.0-0.3,日常对话建议用0.7左右,创意写作可尝试1.0-1.5(过高可能跑题)

📏

max_tokens

最大输出长度

换算 1 token ≈ 0.5个中文字
短回答 100-500 tokens
长文章 1000-2000 tokens

💡 合理设置可以节省成本,避免不必要的长输出

🌊

stream

流式输出开关

True 逐字输出,体验更好
False 一次性返回,适合批处理
推荐 聊天场景用True

💡 流式输出让用户感觉响应更快,提升用户体验

🎯

top_p

核采样的概率阈值

范围 0.1-1.0
作用 控制采样候选集:只在“累计概率 ≤ top_p”的词里采样(值越大越发散)
推荐 0.9(通用平衡值)
0.3-0.6 更确定:代码/抽取/格式化输出(减少跑题与胡编)
0.8-0.95 对话/问答:质量与多样性平衡(多数产品默认区间)
0.95-1.0 脑暴/创意:更多“意外答案”(需要更强约束与复核)

💡 经验法则:答案太“飘/跑题”→ 降低top_p(如0.6→0.4);答案太“死板/重复”→ 提高top_p(如0.8→0.95)。通常与temperature二选一使用,避免同时调整

🚫

frequency_penalty

频率惩罚

范围 -2.0 到 2.0
正值 降低重复内容出现频率
推荐 0.1-0.3(适度避免重复)

💡 适合需要避免重复词句的场景,如文章写作

🌟

presence_penalty

存在惩罚

范围 -2.0 到 2.0
正值 鼓励谈论新话题,促进话题转换
推荐 0.0-0.2(适度增加多样性)

💡 适合需要丰富话题和内容的对话场景

🛑

stop_sequences

停止序列控制

作用 控制输出格式,遇到指定序列停止生成
示例 ["###", "\n\n", "END"]
用途 控制JSON、代码块等格式输出

💡 确保AI输出符合预期格式,避免内容过长

🎯 实用建议

  • 新手用户:使用默认参数,专注于内容质量
  • 成本控制:合理设置max_tokens,避免过度消耗
  • 场景优化:根据任务类型调整temperature
  • 用户体验:聊天场景建议开启stream
  • 减少重复:适当设置frequency_penalty和presence_penalty
  • 格式控制:使用stop_sequences控制输出格式
  • 参数组合:temperature和top_p通常只需设置一个

💡 错误处理最佳实践

在生产环境中,完善的错误处理是确保应用稳定性的关键:

🛡️ 健壮的API调用架构

🔄

带重试机制的调用

自动处理网络异常和临时故障

python
import time
import dashscope
from dashscope import Generation

class RobustLLMClient:
    def __init__(self, api_key, max_retries=3):
        dashscope.api_key = api_key
        self.max_retries = max_retries
    
    def call_with_retry(self, messages, **kwargs):
        """
        带重试机制的API调用
        
        参数说明:
        - messages: 对话消息列表
        - **kwargs: 可变关键字参数,用于接收任意数量的额外参数
                   例如: model='qwen-turbo', temperature=0.7, max_tokens=1000
                   这些参数会被原封不动地传递给 Generation.call()
        
        **kwargs 的作用:
        1. 让函数更灵活,可以接收任意额外参数
        2. 使用 **kwargs 展开时,会将字典形式的参数转换为关键字参数
        3. 例如: call_with_retry(messages, model='qwen-turbo', temperature=0.7)
           这里的 model 和 temperature 就会被 **kwargs 捕获并传递
        """
        for attempt in range(self.max_retries):
            try:
                # **kwargs 在这里展开,将接收到的所有额外参数传递给 Generation.call()
                response = Generation.call(
                    messages=messages,
                    **kwargs  # 例如会展开为: model='qwen-turbo', temperature=0.7
                )
                if response.status_code == 200:
                    return response.output.text
                else:
                    raise Exception(f"API错误:{response.message}")
                
            except Exception as e:
                if attempt == self.max_retries - 1:
                    return f"调用失败:{str(e)}"
                
                # 指数退避策略
                wait_time = 2 ** attempt
                print(f"第{attempt + 1}次失败,{wait_time}秒后重试...")
                time.sleep(wait_time)
        
        return "所有重试均失败"

# 使用示例
client = RobustLLMClient(api_key="your-api-key")

# 示例1:只传递 model 参数(通过 **kwargs 传递)
result = client.call_with_retry([
    {'role': 'user', 'content': '介绍一下Python'}
], model='qwen-turbo')
print(result)

# 示例2:传递多个参数(都会被 **kwargs 捕获并传递给 Generation.call)
result = client.call_with_retry([
    {'role': 'user', 'content': '写一首诗'}
], model='qwen-turbo', temperature=0.9, max_tokens=500)
# 这里的 model, temperature, max_tokens 都会被 **kwargs 接收
# 然后在函数内部通过 **kwargs 展开传递给 Generation.call()

print(result)
⚠️

常见错误类型

识别并处理不同错误

  • 网络超时:增加重试机制
  • API限流:实施退避策略
  • 认证失败:检查API Key
  • 配额耗尽:监控使用量

最佳实践

提升系统稳定性

  • 指数退避:避免频繁重试
  • 熔断机制:防止雪崩效应
  • 多服务商:提高可用性
  • 监控告警:及时发现问题

🎯 生产环境建议

  • 日志记录:详细记录API调用和错误信息
  • 性能监控:监控响应时间和成功率
  • 成本控制:设置使用限额和告警
  • 备用方案:准备多个服务商作为备选

🎯 API调用实际应用案例

参考Chapter3的Prompt设计技巧,这里提供几个实用的API调用案例,帮助你快速上手大模型应用开发。

📝

智能文档助手

自动化文档生成和分析

python
import dashscope
from dashscope import Generation

class DocumentAssistant:
    def __init__(self, api_key):
        dashscope.api_key = api_key
    
    def generate_documentation(self, code_content):
        """生成代码文档"""
        prompt = f"""
你是一位资深的技术文档专家,请为以下代码生成详细的文档:

代码:
{code_content}

请按以下格式输出:
1. 功能概述
2. 参数说明  
3. 返回值说明
4. 使用示例
5. 注意事项

要求:专业、准确、易懂
"""
        
        response = Generation.call(
            model="qwen-turbo",
            messages=[{'role': 'user', 'content': prompt}],
            temperature=0.3
        )
        
        if response.status_code == 200:
            return response.output.text
        else:
            return f"生成失败:{response.message}"

# 使用示例
assistant = DocumentAssistant("your-api-key")
code = "def calculate_factorial(n): return 1 if n <= 1 else n * calculate_factorial(n-1)"
doc = assistant.generate_documentation(code)
print(doc)
🔍

代码质量审查

智能代码分析和优化建议

python
def code_review(api_key, code_snippet, language="Python"):
    """使用API进行代码审查"""
    import dashscope
    from dashscope import Generation
    
    dashscope.api_key = api_key
    
    prompt = f"""
你是一位经验丰富的{language}开发工程师,请审查以下代码:

代码:
{code_snippet}

请从以下角度进行分析:
1. 代码质量和规范性
2. 潜在的bug和安全问题  
3. 性能优化建议
4. 最佳实践建议
5. 改进后的代码示例

输出格式:使用markdown格式,包含代码块
"""
    
    response = Generation.call(
        model="qwen-plus",
        messages=[{'role': 'user', 'content': prompt}],
        temperature=0.2
    )
    
    if response.status_code == 200:
        return response.output.text
    else:
        return f"审查失败:{response.message}"

# 使用示例
code_to_review = """
def get_user_data(user_id):
    query = "SELECT * FROM users WHERE id = " + user_id
    return db.execute(query)
"""

review_result = code_review("your-api-key", code_to_review)
print(review_result)
📱

小红书文案生成器

爆款内容一键生成

python
import dashscope
from dashscope import Generation

class XiaohongshuGenerator:
    def __init__(self, api_key):
        dashscope.api_key = api_key
    
    def generate_content(self, topic, style="种草"):
        """生成小红书文案"""
        prompt = f"""
你是一位专业的小红书博主,擅长写{style}风格的文案。请为主题"{topic}"创作一篇小红书文案。

要求:
1. 标题要吸引人,包含emoji表情
2. 正文要口语化,有亲和力
3. 包含3-5个相关话题标签
4. 字数控制在200-300字
5. 适当使用emoji增加趣味性
6. 结尾要有互动引导

格式示例:
✨ 标题 | emoji emoji

正文内容...

#话题1 #话题2 #话题3

姐妹们有什么想法吗?评论区见~
"""
        
        response = Generation.call(
            model="qwen-turbo",
            messages=[{'role': 'user', 'content': prompt}],
            temperature=0.8,
            max_tokens=500
        )
        
        if response.status_code == 200:
            return response.output.text
        else:
            return f"生成失败:{response.message}"
    
    def generate_batch(self, topics, count=3):
        """批量生成多个版本的文案"""
        results = []
        for topic in topics:
            for i in range(count):
                content = self.generate_content(topic)
                results.append({
                    "topic": topic,
                    "version": i+1,
                    "content": content
                })
        return results

# 使用示例
generator = XiaohongshuGenerator("your-api-key")

# 生成单个文案
content = generator.generate_content("秋冬护肤心得", "种草")
print(content)

# 批量生成
topics = ["健身减肥", "读书推荐", "职场技巧"]
batch_results = generator.generate_batch(topics, count=2)

for result in batch_results:
    print(f"\n=== {result['topic']} - 版本{result['version']} ===")
    print(result['content'])

💡 小红书文案技巧

  • 标题吸睛:使用emoji和关键词组合,提高点击率
  • 内容真实:分享真实体验,增加可信度
  • 话题精准:选择热门话题标签,增加曝光
  • 互动引导:结尾提问,鼓励用户评论互动

🚀 API调用最佳实践

📝 Prompt设计
  • 明确角色定位
  • 提供具体示例
  • 设定输出格式
  • 控制参数范围
⚡ 性能优化
  • 合理设置temperature
  • 控制max_tokens
  • 使用流式输出
  • 实现请求缓存
🛡️ 安全考虑
  • API密钥安全存储
  • 输入内容过滤
  • 输出结果审核
  • 使用量监控

🖥️ 部署自己的大模型(本地运行)

除了调用云端API,你还可以在自己的电脑上部署开源大模型。这样可以完全离线使用,数据更安全,但需要一定的硬件配置。

💻 硬件要求指南

根据你的硬件配置选择合适的模型规模:

📱

入门配置

8GB RAM + 10GB 硬盘

  • ✅ 可运行小型模型(1-3B)
  • ✅ 适合学习和测试
  • ✅ 推荐模型:Qwen1.5-1.8B
  • ⚠️ 性能有限,响应较慢
💻

推荐配置

16GB RAM + 20GB 硬盘

  • ✅ 可运行中型模型(7-13B)
  • ✅ 平衡性能和资源
  • ✅ 推荐模型:Qwen1.5-7B、DeepSeek-7B
  • 🎯 适合大多数开发场景
🚀

高级配置

32GB+ RAM + GPU

  • ✅ 可运行大型模型(30B+)
  • ✅ GPU加速,性能卓越
  • ✅ 推荐模型:Qwen1.5-14B、DeepSeek-67B
  • 🔥 适合生产环境

🛠️ 常用部署工具

🐙

1️⃣ Ollama - 最简单的本地部署工具(强烈推荐)

就像 Docker 一样简单易用

Ollama 是目前最流行、最简单的本地大模型部署工具,一键安装,命令行操作,非常适合开发者。

✨ 核心优势

  • 一键安装:无需配置复杂环境
  • 命令行操作:类似Docker,简单直观
  • 自动下载:自动管理模型文件
  • API支持:提供REST API,方便集成
  • 多平台:支持Windows、macOS、Linux

📦 安装步骤

1
下载Ollama

访问官网下载:https://ollama.ai

💡 支持Windows、macOS、Linux,选择对应版本下载

2
安装并启动

双击安装包,按提示完成安装。安装后会自动启动Ollama服务。

💡 macOS用户可以通过Homebrew安装:brew install ollama

3
下载模型

打开终端,运行以下命令下载模型:

text
# 下载通义千问1.8B模型(推荐新手)
ollama pull qwen:1.8b

# 下载通义千问7B模型(推荐日常使用)
ollama pull qwen:7b

# 下载DeepSeek 7B模型(编程能力强)
ollama pull deepseek-coder:6.7b
4
开始对话

在终端中直接运行:

text
# 启动通义千问对话
ollama run qwen:1.8b

# 启动DeepSeek编程助手
ollama run deepseek-coder:6.7b

💡 第一次运行会加载模型,请耐心等待。后续启动会快很多!

⌨️ Ollama 常用命令速查(建议收藏)

下面是本地部署最常用的一组命令:模型管理(下载/查看/删除)、运行管理(查看/停止)、以及 API 调试与自定义模型。

text
# 1) 查看本地已有模型
ollama list

# 2) 拉取(下载)模型
ollama pull qwen:7b

# 3) 运行模型(进入交互式对话)
ollama run qwen:7b

# 4) 直接把一句话喂给模型(适合脚本)
ollama run qwen:7b "用一句话解释RAG"

# 5) 查看当前正在运行的模型(类似 docker ps)
ollama ps

# 6) 停止某个正在运行的模型
ollama stop qwen:7b

# 7) 查看模型详细信息(参数/模板等)
ollama show qwen:7b

# 8) 删除模型(释放磁盘空间)
ollama rm qwen:7b

# 9) 复制一个模型并重命名(用于做自己的变体)
ollama cp qwen:7b my-qwen:7b

# 10) (进阶)从 Modelfile 创建自定义模型(常用来改 system prompt/模板)
# 新建 Modelfile:
#   FROM qwen:7b
#   SYSTEM "你是一个严谨的Java后端+AI应用工程师,回答要给代码与边界条件"
#   PARAMETER temperature 0.2
ollama create my-qwen:7b -f Modelfile

💡 运行与资源提示: ollama ps 可以快速确认是否在后台占用内存;不使用就 ollama stop 释放资源。

🔌 API 调试(curl 一把梭)
text
# Ollama 默认服务端口:11434
# /api/generate:最常用的生成接口
curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen:7b",
    "prompt": "写一个Java的Hello World",
    "stream": false
  }'

# 流式输出(stream=true),可用于“打字机效果”
curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen:7b",
    "prompt": "用三点总结Transformer",
    "stream": true
  }'

💡 多设备/局域网访问:如果你想让同网段设备访问 Ollama API,需要将服务监听到 0.0.0.0 (不同系统配置方式不同,以 Ollama 文档为准)。本机开发默认 localhost:11434 即可。

🐍

2️⃣ Python调用本地模型

通过代码调用Ollama API

Ollama提供了REST API,可以用任何编程语言调用。这里以Python为例:

🌐 如果不是 localhost 的 Ollama,要改什么?

  • 服务端(跑 Ollama 的那台机器):需要让 Ollama 监听对外地址(否则只能本机访问)。常见做法是设置环境变量 OLLAMA_HOST,例如:0.0.0.0:11434(具体以 Ollama 文档为准)。
  • 网络/防火墙:确保远端机器的 11434 端口允许访问(同网段/公网/安全组)。
  • 安全建议:不要直接暴露到公网。推荐只在内网用,或在前面加反向代理/鉴权(例如 Nginx + Basic Auth / IP 白名单)。
  • 客户端代码:把 base_urlhttp://localhost:11434 改成 http://{远端IP或域名}:11434
python
# 例:调用远端 Ollama(内网机器)
# 假设 Ollama 部署在 192.168.1.50
client = OllamaClient(base_url="http://192.168.1.50:11434")
resp = client.chat("qwen:7b", "解释一下 top_p")
print(resp)

# 如果你用的是域名/反向代理(带鉴权),base_url 改成对应地址即可
# 例如:https://ollama.yourdomain.com

🔧 API调用示例

python
import requests
import json


class OllamaClient:
    def __init__(self, base_url="http://localhost:11434"):
        self.base_url = base_url

    def chat(self, model, message, stream=False):
        """调用本地模型进行对话

        重要:如果一个函数体里出现了 yield,那么这个函数会变成“生成器函数”。
        为了保证:
        - stream=False 时返回字符串(模型完整结果)
        - stream=True 时返回迭代器(逐段产出)
        我们把 yield 放到内部生成器函数里。
        """
        url = f"{self.base_url}/api/generate"

        payload = {
            "model": model,
            "prompt": message,
            "stream": stream
        }

        # 1) 流式:返回一个“内部生成器”,外部 for chunk in client.chat(..., stream=True)
        if stream:
            def _gen():
                try:
                    # 注意:requests 需要 stream=True 才能边下边读
                    response = requests.post(url, json=payload, stream=True)
                    response.raise_for_status()

                    for line in response.iter_lines():
                        if not line:
                            continue
                        data = json.loads(line)
                        chunk = data.get("response", "")
                        if chunk:
                            yield chunk

                        # Ollama 会在最后一条返回 done=true
                        if data.get("done") is True:
                            break
                except Exception as e:
                    yield f"调用失败:{str(e)}"

            return _gen()

        # 2) 非流式:直接返回字符串
        try:
            response = requests.post(url, json=payload, stream=False)
            response.raise_for_status()
            result = response.json()
            return result.get("response", "")
        except Exception as e:
            return f"调用失败:{str(e)}"


# 使用示例
if __name__ == "__main__":
    client = OllamaClient()

    # 非流式(返回字符串)
    response = client.chat("qwen:1.8b", "什么是Python?", stream=False)
    print("通义千问回答:", response)

    # 流式(返回迭代器)
    for chunk in client.chat("deepseek-coder:6.7b", "写一个Python Hello World", stream=True):
        print(chunk, end="", flush=True)

💡 实用技巧

  • 模型选择:根据任务复杂度选择合适大小的模型
  • 内存管理:大模型会占用大量内存,不使用时可以停止服务
  • 批量处理:对于大量文本,可以分批处理避免内存溢出
  • 错误处理:网络连接可能失败,建议添加重试机制

💡 远程调用常见错误排查: 1)Connection refused:端口没开/服务没监听对外; 2)Timeout:网络不可达/防火墙拦截; 3)模型不存在:先在远端执行 ollama list 确认模型标签。

🔗 用 LangChain 访问 Ollama(更贴近真实项目)

如果你后续要做 RAG / Agent,推荐直接用 LangChain 对接 Ollama,把模型调用变成可组合的组件。

text
# 安装 LangChain(Ollama 集成一般在 community 包里)
pip install -U langchain langchain-community
python
from langchain_community.llms import Ollama

# 1) 本地 Ollama
llm = Ollama(model="qwen:7b", base_url="http://localhost:11434")

# 2) 如果是远程 Ollama,把 base_url 改成远端地址即可
# llm = Ollama(model="qwen:7b", base_url="http://192.168.1.50:11434")

result = llm.invoke("用三点解释 top_p 和 temperature 的区别")
print(result)

💡 你在项目里通常会把 base_url 配到环境变量(例如 OLLAMA_BASE_URL), 这样本地/远程切换不需要改代码。

🎉 本地部署优势总结

  • 数据安全:所有数据都在本地处理,不会上传到云端
  • 离线可用:无需网络连接,随时可以使用
  • 成本控制:一次部署,无限使用,无API调用费用
  • 定制化:可以微调模型,适应特定业务需求
  • 响应速度:本地调用速度快,无网络延迟

📚 本章小结

🎯 核心要点回顾

通过本章学习,你已经掌握了大模型API调用的核心技能:

☁️

云端API

最实用的方式

  • ✅ 无需翻墙,访问快速
  • ✅ 价格便宜,性价比高
  • ✅ 新用户有免费额度
  • ✅ 企业级服务,稳定可靠
🔑

平台选择

两大推荐平台

  • 🔷 通义千问:功能全面,适合新手
  • 🔶 DeepSeek:编程专家,价格便宜
  • 📚 两者都有完善的文档
  • 🚀 支持流式输出和高级功能
🛡️

安全实践

保护API Key

  • 🔐 使用环境变量存储
  • 🚫 不要提交到代码仓库
  • 📝 添加到.gitignore文件
  • ⚠️ 定期轮换API Key
⚙️

技术要点

优化与稳定性

  • 🌊 流式输出提升体验
  • 🔄 添加重试机制
  • 📊 合理设置参数
  • 🛠️ 完善错误处理

🎉 学习成果

恭喜你!现在你已经掌握了大模型API调用的核心技能。你可以:

  • 独立获取通义千问和DeepSeek的API Key
  • 安全配置开发环境
  • 编写代码调用大模型API
  • 处理异常和错误情况
  • 优化参数提升输出质量
📖

推荐阅读

  • 📄 通义千问官方文档
  • 📄 DeepSeek API文档
  • 📄 OpenAI SDK文档
  • 📄 Python环境变量最佳实践
🔬

实践建议

  • 🎯 先用免费额度充分测试
  • ⚖️ 对比不同模型的效果
  • 🎛️ 学会控制参数优化输出
  • 📈 监控API使用量和成本

📚 课后习题与面试题

请认真完成以下练习,巩固大模型API调用核心知识

⚠️ 重要提示:这些题目涵盖了API调用常见考点,请务必掌握!

🎯 基础练习题

1. 什么是API Key?为什么它很重要?

2. 简述通义千问和DeepSeek的主要特点

3. 什么是流式输出?它有什么优势?

💼 面试题

1. 【技术题】如何设计一个健壮的大模型API调用架构?

2. 【场景题】在高峰期API调用失败率上升,你会如何排查和解决?

🚀 实战练习

1. 请编写一个Python函数,实现通义千问API的调用,包含错误处理和重试机制。

💡 学习建议

  • 先掌握基础API调用,再学习高级功能
  • 多练习不同服务商的API调用方式
  • 重视错误处理和异常情况的处理
  • 建立自己的API调用工具类
  • 关注API使用成本,合理控制调用频率
← 上一章 下一章 →