小白必看！通义千问2.5-7B部署全攻略，从安装到对话实战

1. 引言

你是不是也想在本地电脑上运行一个属于自己的AI助手？看到别人玩大模型很酷，但自己尝试时总被复杂的安装步骤、环境配置劝退？别担心，今天这篇教程就是为你准备的。

通义千问2.5-7B-Instruct是阿里在2024年9月推出的一个70亿参数的中等规模模型。别看它体积不算最大，但能力相当全面——能写代码、能解数学题、能处理长文档，还支持工具调用。最重要的是，它完全开源免费，个人和企业都能用。

以前部署一个大模型，你可能需要折腾Python环境、CUDA驱动、各种依赖库，一个环节出错就得从头再来。现在有了Docker，我们可以把整个运行环境打包成一个“集装箱”，一键就能启动。配合vLLM这个高性能推理引擎，还能让模型跑得更快。

这篇教程会手把手带你完成从零到一的完整部署过程。即使你之前没接触过Docker，跟着步骤走也能在30分钟内拥有一个能对话、能调用的本地AI服务。

2. 部署前准备：检查你的“装备”

2.1 硬件要求：你的电脑够用吗？

在开始之前，先确认一下你的电脑配置。通义千问2.5-7B-Instruct对硬件有一定要求，但门槛并不算高：

推荐配置（能获得较好体验）

• 显卡：NVIDIA GPU，显存至少8GB（比如RTX 3060、RTX 4060）
• 内存：16GB或以上
• 存储空间：至少30GB可用空间（用来放模型文件）
• 操作系统：Linux（Ubuntu 20.04/22.04）、Windows 10/11、macOS都可以

最低配置（也能跑，但可能慢一些）

• 如果没有独立显卡，用CPU也能运行，只是速度会慢很多
• 内存8GB勉强够用，但处理长文本时可能会卡顿
• 存储空间至少需要15GB

怎么查看自己的配置？

• Windows：按Win+R，输入dxdiag，在“显示”标签页看显卡信息
• Linux：在终端输入nvidia-smi看显卡信息，free -h看内存
• macOS：点击左上角苹果图标→关于本机

2.2 软件准备：安装必要的工具

我们需要两个核心工具：Docker和NVIDIA驱动支持。

第一步：安装Docker Docker就像是一个“应用集装箱”，能把模型和所有依赖打包在一起运行。

对于Ubuntu系统，打开终端依次执行：

# 更新软件包列表
sudo apt update

# 安装必要的依赖
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common

# 添加Docker官方GPG密钥
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 添加Docker仓库
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装Docker引擎
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

# 将当前用户添加到docker组（避免每次都要sudo）
sudo usermod -aG docker $USER

# 重启docker服务
sudo systemctl restart docker

安装完成后，验证一下：

docker --version

如果看到类似Docker version 24.0.7的输出，说明安装成功。

第二步：配置NVIDIA支持（如果你有NVIDIA显卡） 如果你的电脑有NVIDIA显卡，还需要安装NVIDIA Container Toolkit，让Docker能使用GPU。

# 添加NVIDIA仓库
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

# 安装工具包
sudo apt update
sudo apt install -y nvidia-container-toolkit

# 重启docker
sudo systemctl restart docker

测试GPU是否能在Docker中使用：

docker run --rm --gpus all nvidia/cuda:12.2-base nvidia-smi

如果看到显卡信息表格，说明配置成功。如果报错，可能需要重启电脑。

小提示：如果你是Windows或macOS用户，可以直接下载Docker Desktop，它包含了图形界面，安装更简单。Windows用户还需要安装WSL2（Windows Subsystem for Linux）。

3. 获取模型文件：准备好“大脑”

模型文件就是AI的“大脑”，我们需要先下载它。通义千问2.5-7B-Instruct的模型文件大约28GB（FP16格式），下载需要一些时间。

3.1 创建模型存放目录

首先，找个地方存放模型文件。建议放在空间充足的磁盘分区：

# 创建一个专门存放模型的目录
mkdir -p /data/models/qwen2.5-7b-instruct
cd /data/models/qwen2.5-7b-instruct

如果你没有/data目录，也可以放在其他地方，比如：

mkdir -p ~/ai_models/qwen2.5-7b-instruct
cd ~/ai_models/qwen2.5-7b-instruct

3.2 下载模型文件

有几种方式可以获取模型文件：

方式一：从ModelScope下载（推荐给国内用户） ModelScope是阿里推出的模型社区，下载速度通常比较快。

# 安装ModelScope库
pip install modelscope

# 使用Python脚本下载
python -c "
from modelscope import snapshot_download
model_dir = snapshot_download('Qwen/Qwen2.5-7B-Instruct', cache_dir='/data/models')
print(f'模型已下载到: {model_dir}')
"

方式二：从Hugging Face下载 如果你能访问Hugging Face，也可以用他们的工具：

# 安装huggingface-hub
pip install huggingface-hub

# 下载模型
huggingface-cli download Qwen/Qwen2.5-7B-Instruct --local-dir /data/models/qwen2.5-7b-instruct --local-dir-use-symlinks False

方式三：手动下载（如果上面方法都不行） 如果网络条件有限，可以尝试：

1. 找朋友用上面的方法下载后拷贝给你
2. 使用网盘分享（注意检查文件完整性）
3. 在公司或学校的服务器上下载后传输到本地

3.3 检查模型文件

下载完成后，检查目录里应该有这些文件：

/data/models/qwen2.5-7b-instruct/
├── config.json              # 模型配置文件
├── model.safetensors.index.json  # 模型索引文件
├── model-00001-of-00004.safetensors  # 模型权重文件（分片）
├── model-00002-of-00004.safetensors
├── model-00003-of-00004.safetensors
├── model-00004-of-00004.safetensors
├── tokenizer_config.json    # 分词器配置
├── tokenizer.json          # 分词器文件
└── special_tokens_map.json # 特殊token映射

如果文件齐全，就可以进入下一步了。下载过程可能需要1-2小时，取决于你的网速。

4. 一键部署：启动你的AI服务

现在到了最激动人心的环节——启动模型服务。我们会用Docker+vLLM的组合，这是目前最简单高效的部署方式。

4.1 理解部署命令

先来看完整的启动命令，我会逐行解释每个参数的作用：

docker run --runtime nvidia --gpus "device=0" \
    -p 9000:9000 \
    --ipc=host \
    -v /data/models/qwen2.5-7b-instruct:/qwen2.5-7b-instruct \
    -it --rm \
    vllm/vllm-openai:latest \
    --model /qwen2.5-7b-instruct \
    --dtype float16 \
    --max-parallel-loading-workers 1 \
    --max-model-len 10240 \
    --enforce-eager \
    --host 0.0.0.0 \
    --port 9000 \
    --enable-auto-tool-choice \
    --tool-call-parser hermes

参数解释：

参数	作用	如果出问题怎么调整
--gpus "device=0"	使用第0号GPU（如果你有多张显卡）	如果只有一张卡，这个参数可以去掉
-p 9000:9000	把容器内的9000端口映射到主机的9000端口	如果9000端口被占用，可以改成-p 8080:9000
-v /data/models/...	把本地的模型目录挂载到容器里	确保路径正确，如果模型放在别处就改这里
--model /qwen2.5-7b-instruct	指定模型路径（容器内的路径）	要和-v挂载的路径对应
--dtype float16	使用半精度浮点数，节省显存	如果显存不够，可以改成--dtype bfloat16
--max-model-len 10240	最大上下文长度10240个token	如果处理长文档，可以增加到32768
--enforce-eager	禁用CUDA Graph，提高兼容性	如果启动报错，可以去掉这个参数
--enable-auto-tool-choice	启用自动工具选择	如果要使用函数调用功能，必须开启
--tool-call-parser hermes	使用hermes格式解析工具调用	对于通义千问模型，用hermes或qwen都可以

4.2 实际执行部署

打开终端，确保你在有模型文件的目录下，然后直接运行上面的命令。

第一次运行时会下载vLLM的Docker镜像，大约需要下载1-2GB，取决于你的网络速度。下载完成后，你会看到类似这样的输出：

Downloading vllm/vllm-openai:latest...
...
Starting vLLM engine with model: /qwen2.5-7b-instruct
Loading model weights...
Initializing distributed environment...
Model loaded in 45.23 seconds
Uvicorn running on http://0.0.0.0:9000 (Press CTRL+C to quit)

看到最后一行Uvicorn running on http://0.0.0.0:9000，恭喜你！模型服务已经成功启动了。

几个常见情况的处理：

情况1：显存不够怎么办？ 如果启动时报错CUDA out of memory，说明显卡显存不足。可以尝试：

# 方法1：使用更低的精度（如果显卡支持bfloat16）
--dtype bfloat16

# 方法2：减少最大上下文长度
--max-model-len 4096

# 方法3：使用CPU模式（会很慢，仅测试用）
# 去掉--gpus参数，添加--device cpu

情况2：没有GPU怎么办？ 如果你的电脑没有NVIDIA显卡，可以用CPU模式运行：

docker run \
    -p 9000:9000 \
    -v /data/models/qwen2.5-7b-instruct:/qwen2.5-7b-instruct \
    -it --rm \
    vllm/vllm-openai:latest \
    --model /qwen2.5-7b-instruct \
    --device cpu \
    --dtype float32 \
    --host 0.0.0.0 --port 9000

情况3：想用更小的模型版本 如果28GB的完整版对你来说太大，可以考虑使用量化版本（4-8GB），但效果会略有下降。你需要在下载模型时选择GGUF格式的量化版本。

4.3 验证服务是否正常

服务启动后，打开浏览器访问：http://localhost:9000/docs

如果能看到Swagger API文档页面，说明服务运行正常。你也可以用curl命令测试：

curl http://localhost:9000/v1/models

应该返回类似这样的JSON：

{
  "object": "list",
  "data": [
    {
      "id": "/qwen2.5-7b-instruct",
      "object": "model",
      "created": 1730000000,
      "owned_by": "vllm"
    }
  ]
}

5. 第一次对话：和你的AI助手聊天

服务跑起来了，现在让我们写个简单的Python脚本来和它对话。

5.1 安装必要的Python库

打开一个新的终端窗口（不要关闭运行模型的终端），安装openai库：

pip install openai

如果你还没有安装Python，需要先安装Python 3.8或以上版本。

5.2 编写聊天脚本

创建一个新文件，命名为chat.py，内容如下：

# -*- coding: utf-8 -*-
import json
from openai import OpenAI

# 配置连接信息
# 注意：我们用的是本地服务，所以密钥为空
openai_api_key = "EMPTY"
openai_api_base = "http://localhost:9000/v1"

# 创建客户端
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)

# 获取可用的模型列表
models = client.models.list()
print(f"可用模型: {[m.id for m in models.data]}")

# 选择第一个模型（通常就是我们部署的模型）
model = models.data[0].id
print(f"使用模型: {model}")

def simple_chat():
    """简单的单轮对话"""
    print("=== 简单对话测试 ===")
    
    # 构建对话消息
    messages = [
        {"role": "system", "content": "你是一个乐于助人的AI助手，回答要简洁明了。"},
        {"role": "user", "content": "用Python写一个函数，计算斐波那契数列的第n项"}
    ]
    
    # 发送请求
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        max_tokens=500,  # 最大生成token数
        temperature=0.7,  # 创造性，0-1之间，越大越有创意
    )
    
    # 打印回复
    print("问题:", messages[1]["content"])
    print("回答:", response.choices[0].message.content)
    print()

def streaming_chat():
    """流式对话，可以看到一个字一个字地输出"""
    print("=== 流式对话测试 ===")
    
    messages = [
        {"role": "user", "content": "给我讲一个关于程序员的笑话"}
    ]
    
    print("问题:", messages[0]["content"])
    print("回答: ", end="", flush=True)
    
    # 流式请求
    stream = client.chat.completions.create(
        model=model,
        messages=messages,
        stream=True,
        temperature=0.8,
    )
    
    full_response = ""
    for chunk in stream:
        content = chunk.choices[0].delta.content
        if content:
            print(content, end="", flush=True)
            full_response += content
    
    print("\n")
    return full_response

def multi_turn_chat():
    """多轮对话，保持上下文"""
    print("=== 多轮对话测试 ===")
    
    # 初始化对话历史
    conversation = [
        {"role": "system", "content": "你是一个知识渊博的历史老师，用生动有趣的方式讲解历史。"}
    ]
    
    questions = [
        "秦始皇统一六国是在哪一年？",
        "他统一后做了哪些重要改革？",
        "这些改革对后世有什么影响？"
    ]
    
    for i, question in enumerate(questions, 1):
        print(f"\n第{i}轮:")
        print("你:", question)
        
        # 添加用户问题到对话历史
        conversation.append({"role": "user", "content": question})
        
        # 获取回答
        response = client.chat.completions.create(
            model=model,
            messages=conversation,
            max_tokens=300,
        )
        
        answer = response.choices[0].message.content
        print("AI:", answer)
        
        # 添加AI回答到对话历史
        conversation.append({"role": "assistant", "content": answer})

if __name__ == "__main__":
    # 运行测试
    simple_chat()
    streaming_chat()
    multi_turn_chat()
    
    print("所有测试完成！")

5.3 运行测试

保存文件后，在终端运行：

python chat.py

你应该能看到类似这样的输出：

可用模型: ['/qwen2.5-7b-instruct']
使用模型: /qwen2.5-7b-instruct
=== 简单对话测试 ===
问题: 用Python写一个函数，计算斐波那契数列的第n项
回答: 当然，这是一个计算斐波那契数列第n项的Python函数：

```python
def fibonacci(n):
    if n <= 0:
        return "输入必须为正整数"
    elif n == 1:
        return 0
    elif n == 2:
        return 1
    else:
        a, b = 0, 1
        for _ in range(2, n):
            a, b = b, a + b
        return b

# 测试
print(fibonacci(1))  # 输出: 0
print(fibonacci(5))  # 输出: 3
print(fibonacci(10)) # 输出: 34

这个函数的时间复杂度是O(n)，空间复杂度是O(1)。

=== 流式对话测试 === 问题: 给我讲一个关于程序员的笑话 回答: 为什么程序员总是分不清万圣节和圣诞节？ 因为 Oct 31 == Dec 25！ （Oct是八进制，Dec是十进制，八进制的31等于十进制的25）

=== 多轮对话测试 ===

第1轮: 你: 秦始皇统一六国是在哪一年？ AI: 秦始皇统一六国是在公元前221年。这一年，秦国灭掉了最后一个诸侯国齐国，完成了对中国历史上第一次大一统。

第2轮: 你: 他统一后做了哪些重要改革？ AI: 秦始皇统一后推行了一系列重要改革，史称"秦制"：

1. 书同文：统一使用小篆作为标准文字
2. 车同轨：统一车辆和道路的规格
3. 统一度量衡：制定标准计量单位
4. 推行郡县制：废除分封制，建立中央集权
5. 修筑长城：连接各国长城防御匈奴

第3轮: 你: 这些改革对后世有什么影响？ AI: 秦始皇的改革对后世产生了深远影响：

1. 奠定了中国两千多年中央集权制度的基础
2. 文字统一促进了文化交流和民族融合
3. 度量衡统一方便了经济发展和贸易
4. 郡县制成为后世行政区划的蓝本
5. 长城成为中华民族的象征和重要文化遗产

所有测试完成！

看到这些输出，说明你的AI助手已经能正常工作了！

## 6. 高级功能：让AI学会使用工具

通义千问2.5-7B的一个强大功能是支持“工具调用”（Function Calling）。这意味着AI不仅能回答问题，还能调用外部工具，比如查询天气、搜索信息、操作数据库等。

### 6.1 什么是工具调用？

简单来说，就是让AI学会“使用工具”。比如你问“北京今天天气怎么样？”，AI不会直接编造一个答案，而是会调用一个天气查询函数，获取真实数据后再回答你。

### 6.2 实现一个天气查询工具

让我们创建一个简单的天气查询示例。新建一个文件`weather_tool.py`：

```python
# -*- coding: utf-8 -*-
from openai import OpenAI
import json
import datetime

# 配置客户端
client = OpenAI(
    api_key="EMPTY",
    base_url="http://localhost:9000/v1"
)

# 获取模型
models = client.models.list()
model = models.data[0].id

# 模拟的天气数据（真实场景中这里应该调用天气API）
weather_data = {
    "北京": {"temperature": "25°C", "condition": "晴", "humidity": "45%"},
    "上海": {"temperature": "28°C", "condition": "多云", "humidity": "65%"},
    "广州": {"temperature": "32°C", "condition": "阵雨", "humidity": "80%"},
    "深圳": {"temperature": "31°C", "condition": "多云转晴", "humidity": "75%"},
    "杭州": {"temperature": "27°C", "condition": "小雨", "humidity": "70%"}
}

def get_weather(city: str, date: str = None) -> str:
    """
    获取指定城市的天气信息
    
    参数:
        city: 城市名称
        date: 日期（格式：YYYY-MM-DD），默认为今天
        
    返回:
        天气信息字符串
    """
    if date is None:
        date = datetime.datetime.now().strftime("%Y-%m-%d")
    
    if city in weather_data:
        info = weather_data[city]
        return f"{date} {city}的天气：气温{info['temperature']}，{info['condition']}，湿度{info['humidity']}"
    else:
        return f"抱歉，暂时没有{city}的天气信息"

def get_current_time(timezone: str = "Asia/Shanghai") -> str:
    """
    获取当前时间
    
    参数:
        timezone: 时区，默认为亚洲/上海
        
    返回:
        当前时间字符串
    """
    now = datetime.datetime.now()
    return f"当前时间（{timezone}）：{now.strftime('%Y-%m-%d %H:%M:%S')}"

# 定义工具列表
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称，例如：北京、上海、广州"
                    },
                    "date": {
                        "type": "string",
                        "description": "日期，格式为YYYY-MM-DD，默认为今天"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "获取当前时间",
            "parameters": {
                "type": "object",
                "properties": {
                    "timezone": {
                        "type": "string",
                        "description": "时区名称，例如：Asia/Shanghai, America/New_York",
                        "default": "Asia/Shanghai"
                    }
                },
                "required": []
            }
        }
    }
]

def chat_with_tools(user_query):
    """与AI对话，支持工具调用"""
    
    # 初始化消息历史
    messages = [
        {"role": "system", "content": "你是一个有用的助手，可以查询天气和时间。如果用户询问相关信息，请调用相应的工具。"},
        {"role": "user", "content": user_query}
    ]
    
    print(f"\n用户: {user_query}")
    print("-" * 50)
    
    # 第一次请求：AI决定是否需要调用工具
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        tools=tools,
        tool_choice="auto",  # 让AI自动决定是否调用工具
    )
    
    response_message = response.choices[0].message
    
    # 检查AI是否想调用工具
    if response_message.tool_calls:
        print("AI决定调用工具...")
        
        # 处理每个工具调用
        for tool_call in response_message.tool_calls:
            function_name = tool_call.function.name
            function_args = json.loads(tool_call.function.arguments)
            
            print(f"调用工具: {function_name}")
            print(f"参数: {function_args}")
            
            # 根据工具名称调用相应的函数
            if function_name == "get_weather":
                function_response = get_weather(**function_args)
            elif function_name == "get_current_time":
                function_response = get_current_time(**function_args)
            else:
                function_response = f"未知工具: {function_name}"
            
            print(f"工具返回: {function_response}")
            
            # 将工具调用和结果添加到消息历史
            messages.append(response_message)  # 添加AI的消息（包含工具调用）
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "name": function_name,
                "content": function_response
            })
        
        # 第二次请求：AI基于工具结果生成最终回复
        print("\nAI基于工具结果生成回答...")
        second_response = client.chat.completions.create(
            model=model,
            messages=messages,
            tools=tools,
        )
        
        final_answer = second_response.choices[0].message.content
        print(f"AI: {final_answer}")
        
    else:
        # 如果AI没有调用工具，直接输出回答
        print(f"AI: {response_message.content}")

if __name__ == "__main__":
    # 测试几个查询
    test_queries = [
        "北京今天天气怎么样？",
        "现在几点了？",
        "帮我查一下上海明天的天气",
        "广州和深圳的天气对比一下",
        "讲一个笑话"  # 这个不需要工具调用
    ]
    
    for query in test_queries:
        chat_with_tools(query)
        print("\n" + "="*60 + "\n")

6.3 运行工具调用示例

保存文件后运行：

python weather_tool.py

你会看到类似这样的输出：

用户: 北京今天天气怎么样？
--------------------------------------------------
AI决定调用工具...
调用工具: get_weather
参数: {'city': '北京'}
工具返回: 2024-01-15 北京的天⽓：⽓温25°C，晴，湿度45%

AI基于工具结果生成回答...
AI: 根据查询结果，北京今天（2024-01-15）的天气情况是：气温25°C，晴天，湿度45%。天气不错，适合外出活动。

============================================================

用户: 现在几点了？
--------------------------------------------------
AI决定调用工具...
调用工具: get_current_time
参数: {}
工具返回: 当前时间（Asia/Shanghai）：2024-01-15 14:30:25

AI基于工具结果生成回答...
AI: 现在是北京时间2024年1月15日14点30分25秒。

============================================================

用户: 讲一个笑话
--------------------------------------------------
AI: 为什么程序员讨厌自然？
因为里面有太多bug！（虫子）

这个例子展示了AI如何：

1. 理解用户的问题需要什么工具
2. 自动调用合适的工具
3. 基于工具返回的结果生成回答

在实际应用中，你可以把get_weather函数替换成真正的天气API调用，或者添加更多工具，比如：

• 搜索网页信息
• 查询数据库
• 发送邮件
• 控制智能设备
• 等等

7. 常见问题与解决方案

7.1 启动时遇到问题怎么办？

问题1：端口被占用

Error: Port 9000 is already in use

解决：换一个端口，比如把-p 9000:9000改成-p 9001:9000

问题2：权限不足

Got permission denied while trying to connect to the Docker daemon socket

解决：把当前用户加入docker组，然后重新登录

sudo usermod -aG docker $USER
# 注销重新登录，或者执行：
newgrp docker

问题3：CUDA版本不兼容

CUDA error: no kernel image is available for execution on the device

解决：检查CUDA版本，可能需要更新显卡驱动

nvidia-smi  # 查看CUDA版本
# 如果版本太旧，去NVIDIA官网下载新驱动

7.2 运行速度慢怎么办？

原因1：使用CPU模式 CPU模式比GPU慢几十倍，如果可能尽量用GPU。

原因2：显存不足，使用了内存交换 检查是否因为显存不足导致使用了系统内存：

# 查看GPU使用情况
nvidia-smi

如果看到显存接近100%，可以尝试：

• 减小--max-model-len参数
• 使用量化版本的模型
• 关闭其他占用显存的程序

原因3：模型首次加载慢 第一次加载模型需要时间，后续请求会快很多。

7.3 如何优化性能？

使用量化模型 如果你只有8GB显存，可以考虑使用4bit量化的GGUF版本：

1. 下载量化模型（大约4GB）
2. 使用llama.cpp或类似工具部署
3. 速度可能稍慢，但显存占用大大减少

调整参数

# 增加批处理大小，提高吞吐量
--max-num-batched-tokens 2048

# 使用更快的注意力机制
--attention-backend flash-attn

# 调整工作线程数（根据CPU核心数）
--worker-use-ray

7.4 如何长期运行服务？

上面的命令加了--rm参数，容器退出后会自动删除。如果想长期运行：

# 使用-d参数在后台运行
docker run --runtime nvidia --gpus "device=0" \
    -p 9000:9000 \
    --ipc=host \
    -v /data/models/qwen2.5-7b-instruct:/qwen2.5-7b-instruct \
    --name qwen-server \
    -d \  # 后台运行
    vllm/vllm-openai:latest \
    --model /qwen2.5-7b-instruct \
    --dtype float16 \
    --host 0.0.0.0 \
    --port 9000

管理容器：

# 查看运行状态
docker ps

# 查看日志
docker logs qwen-server

# 停止服务
docker stop qwen-server

# 启动已停止的服务
docker start qwen-server

# 删除服务
docker rm qwen-server

8. 总结

通过这篇教程，你应该已经成功在本地部署了通义千问2.5-7B-Instruct模型，并且学会了如何与它对话、如何使用工具调用功能。让我们回顾一下关键步骤：

第一步：环境准备

• 检查电脑配置（推荐有8GB以上显存的NVIDIA显卡）
• 安装Docker和NVIDIA驱动支持
• 准备好30GB左右的存储空间

第二步：获取模型

• 从ModelScope或Hugging Face下载模型文件
• 确认文件完整（约28GB）

第三步：一键部署

• 使用Docker+vLLM组合启动服务
• 一个命令搞定所有依赖和环境配置
• 服务运行在localhost:9000

第四步：测试对话

• 安装openai Python库
• 编写简单的聊天脚本
• 测试单轮、多轮、流式对话

第五步：高级功能

• 实现工具调用（Function Calling）
• 让AI学会使用外部工具
• 扩展更多实用功能

你现在的收获：

1. 拥有了一个本地运行的AI助手，随时可用
2. 理解了Docker部署大模型的基本流程
3. 掌握了通过API调用模型的方法
4. 学会了如何让AI使用工具扩展能力

下一步可以尝试：

• 为你的AI助手开发一个Web界面
• 集成到现有的应用程序中
• 尝试不同的模型参数（temperature、max_tokens等）
• 探索更多工具调用场景
• 学习如何微调模型，让它更懂你的需求

部署大模型听起来很复杂，但用对工具和方法后，其实比想象中简单。通义千问2.5-7B-Instruct作为一个中等规模的模型，在性能和资源消耗之间取得了很好的平衡，非常适合个人开发者和小团队使用。

现在，你的本地AI助手已经就绪，接下来就是发挥创意，用它来解决实际问题的时候了。无论是写代码、分析文档、回答问题，还是作为一个智能聊天伙伴，它都能给你带来惊喜。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。