DeepSeek-R1-Distill-Qwen-1.5B入门指南：如何用API方式调用Streamlit后端推理服务

想在自己的应用里集成一个智能对话助手，但又担心数据隐私和云端成本？今天给大家介绍一个超轻量、全本地部署的解决方案——DeepSeek-R1-Distill-Qwen-1.5B模型。这个模型只有1.5B参数，却融合了DeepSeek的逻辑推理能力和Qwen的成熟架构，经过蒸馏优化后，在普通电脑上就能流畅运行。

更重要的是，我们不仅会部署一个可视化的聊天界面，还会教你如何通过API方式调用这个服务，让你可以轻松地把AI能力集成到自己的项目中。无论你是想做个智能客服、代码助手，还是个人知识库，这套方案都能帮你快速实现。

1. 项目核心优势：为什么选择这个方案？

在开始动手之前，我们先看看这个方案有哪些吸引人的地方。了解清楚这些优势，你就能明白为什么值得花时间部署它。

1.1 全本地化运行，数据绝对安全

所有数据都在你的本地机器上处理，完全不经过任何云端服务器。这意味着：

• 隐私零风险：你的对话内容、问题、答案都不会离开你的电脑
• 网络不依赖：断网环境下照样能用，不受网络波动影响
• 成本可控制：没有API调用费用，用多少次都不花钱

模型文件就放在本地的/root/ds_1.5b路径下，推理过程完全在本地完成。对于处理敏感信息或者需要高度保密的应用场景，这个特性特别重要。

1.2 超轻量设计，硬件要求亲民

1.5B的参数规模听起来可能不小，但经过蒸馏优化后，实际运行需求大大降低：

• 低显存需求：4GB显存的GPU就能流畅运行
• CPU也能跑：没有独立显卡？用CPU模式照样可以工作
• 响应速度快：本地推理，没有网络延迟，回答秒级返回

我测试过，在一台普通的游戏笔记本上，这个模型就能很好地运行，完全不需要专业的服务器硬件。

1.3 专业推理能力，不只是聊天

这个模型最厉害的地方在于它的逻辑推理能力。它不只是简单地生成文本，而是真的会“思考”：

• 思维链推理：解题时会展示完整的思考过程
• 代码生成：写出的代码逻辑清晰，注释完整
• 数学解题：能解方程、做证明，步骤详细
• 逻辑分析：复杂问题能拆解成简单步骤

你可以把它想象成一个随时待命的私人助教，不仅给答案，还教你怎么得到答案。

2. 环境准备与快速部署

好了，心动不如行动，我们来看看怎么把这个服务跑起来。整个过程比你想的要简单得多。

2.1 基础环境检查

首先确认你的环境是否满足基本要求：

# 检查Python版本
python --version
# 需要Python 3.8或更高版本

# 检查PyTorch是否安装
python -c "import torch; print(torch.__version__)"
# 建议使用PyTorch 2.0+

# 检查CUDA（如果有GPU）
python -c "import torch; print(torch.cuda.is_available())"

如果你的环境里还没有这些，别担心，我们可以一步步来。

2.2 一键安装依赖

创建一个新的项目目录，然后安装所有需要的包：

# 创建项目目录
mkdir deepseek-chatbot
cd deepseek-chatbot

# 创建requirements.txt文件
cat > requirements.txt << 'EOF'
streamlit>=1.28.0
torch>=2.0.0
transformers>=4.35.0
accelerate>=0.24.0
sentencepiece>=0.1.99
protobuf>=3.20.0
EOF

# 安装依赖
pip install -r requirements.txt

这些包都是必需的：

• streamlit：用来构建Web界面
• torch：深度学习框架
• transformers：加载和使用模型
• accelerate：优化模型加载和推理
• sentencepiece：分词器需要
• protobuf：模型文件解析需要

2.3 下载模型文件

模型文件比较大，我们直接从魔塔平台获取。如果你已经有下载好的模型，可以跳过这一步。

# download_model.py
import os
from huggingface_hub import snapshot_download

# 创建模型保存目录
model_dir = "/root/ds_1.5b"
os.makedirs(model_dir, exist_ok=True)

# 下载模型（这里需要你有魔塔的访问权限）
# 如果没有，可以从其他镜像源下载
print("开始下载模型文件...")
snapshot_download(
    repo_id="deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B",
    local_dir=model_dir,
    local_dir_use_symlinks=False
)
print("模型下载完成！")

运行这个脚本，模型就会下载到本地。下载时间取决于你的网速，模型大小约3GB左右。

3. 构建Streamlit聊天界面

现在我们来创建主要的应用文件。这个界面会让你感觉像是在用专业的聊天工具。

3.1 创建主应用文件

创建一个名为app.py的文件，这是我们的核心应用：

# app.py
import streamlit as st
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
import time

# 设置页面配置
st.set_page_config(
    page_title="DeepSeek R1 智能助手",
    page_icon="🤖",
    layout="wide"
)

# 在侧边栏添加说明
with st.sidebar:
    st.title("🧠 DeepSeek R1 助手")
    st.markdown("""
    ### 功能特点
    - 🏠 **全本地运行**：数据不出本地
    - ⚡ **快速响应**：秒级回答
    - 🔒 **隐私安全**：零云端传输
    - 🧩 **多场景适用**：代码、数学、逻辑推理
    
    ### 使用提示
    1. 输入问题后按回车
    2. 模型会展示思考过程
    3. 点击清空按钮重置对话
    """)
    
    # 清空对话按钮
    if st.button("🧹 清空对话", use_container_width=True):
        st.session_state.messages = []
        st.session_state.chat_history = []
        torch.cuda.empty_cache() if torch.cuda.is_available() else None
        st.rerun()

# 初始化对话历史
if "messages" not in st.session_state:
    st.session_state.messages = []
if "chat_history" not in st.session_state:
    st.session_state.chat_history = []

# 缓存加载模型和分词器
@st.cache_resource
def load_model():
    """加载模型和分词器，只执行一次"""
    model_path = "/root/ds_1.5b"
    
    st.info(f"🚀 正在加载模型: {model_path}")
    start_time = time.time()
    
    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
    
    # 加载模型
    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
        device_map="auto",
        trust_remote_code=True
    )
    
    # 设置为评估模式
    model.eval()
    
    end_time = time.time()
    st.success(f"✅ 模型加载完成！耗时: {end_time - start_time:.2f}秒")
    
    return tokenizer, model

# 加载模型
tokenizer, model = load_model()

# 显示聊天消息
st.title("💬 DeepSeek R1 智能对话助手")

# 显示历史消息
for message in st.session_state.messages:
    with st.chat_message(message["role"]):
        st.markdown(message["content"])

# 聊天输入框
if prompt := st.chat_input("考考 DeepSeek R1..."):
    # 添加用户消息
    st.session_state.messages.append({"role": "user", "content": prompt})
    with st.chat_message("user"):
        st.markdown(prompt)
    
    # 生成AI回复
    with st.chat_message("assistant"):
        message_placeholder = st.empty()
        full_response = ""
        
        # 构建对话历史
        chat_history = st.session_state.chat_history + [{"role": "user", "content": prompt}]
        
        # 应用聊天模板
        inputs = tokenizer.apply_chat_template(
            chat_history,
            add_generation_prompt=True,
            return_tensors="pt"
        )
        
        # 移动输入到正确的设备
        if torch.cuda.is_available():
            inputs = inputs.to("cuda")
        
        # 生成回复
        with torch.no_grad():  # 节省显存
            outputs = model.generate(
                inputs,
                max_new_tokens=2048,
                temperature=0.6,
                top_p=0.95,
                do_sample=True,
                pad_token_id=tokenizer.eos_token_id
            )
        
        # 解码回复
        response = tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)
        
        # 格式化回复（处理思考过程标签）
        formatted_response = response.replace("<|begin_of_thought|>", "**思考过程：**\n\n").replace("<|end_of_thought|>", "\n\n**最终回答：**\n\n")
        
        # 流式显示回复
        for chunk in formatted_response:
            full_response += chunk
            message_placeholder.markdown(full_response + "▌")
            time.sleep(0.01)  # 控制显示速度
        
        message_placeholder.markdown(full_response)
    
    # 更新对话历史
    st.session_state.messages.append({"role": "assistant", "content": full_response})
    st.session_state.chat_history = chat_history + [{"role": "assistant", "content": response}]

3.2 启动聊天服务

保存好app.py文件后，启动服务非常简单：

# 启动Streamlit服务
streamlit run app.py --server.port 8501 --server.address 0.0.0.0

看到终端输出类似下面的信息，就说明服务启动成功了：

You can now view your Streamlit app in your browser.
  Local URL: http://localhost:8501
  Network URL: http://192.168.1.100:8501

打开浏览器访问http://localhost:8501，就能看到聊天界面了。

4. 添加API接口功能

现在到了最关键的部分——如何通过API调用这个服务。这样你就能在其他程序里使用这个AI能力了。

4.1 创建API服务文件

我们创建一个新的文件api_server.py，专门提供API接口：

# api_server.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
import uvicorn
import time

# 创建FastAPI应用
app = FastAPI(title="DeepSeek R1 API服务", version="1.0.0")

# 定义请求和响应模型
class ChatMessage(BaseModel):
    role: str  # "user" 或 "assistant"
    content: str

class ChatRequest(BaseModel):
    messages: List[ChatMessage]
    max_tokens: Optional[int] = 2048
    temperature: Optional[float] = 0.6
    top_p: Optional[float] = 0.95

class ChatResponse(BaseModel):
    response: str
    thinking_process: Optional[str] = None
    final_answer: Optional[str] = None
    usage: dict

# 全局变量存储模型和分词器
tokenizer = None
model = None

def load_models():
    """加载模型和分词器"""
    global tokenizer, model
    
    if tokenizer is None or model is None:
        model_path = "/root/ds_1.5b"
        print(f"正在加载模型: {model_path}")
        
        # 加载分词器
        tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
        
        # 加载模型
        model = AutoModelForCausalLM.from_pretrained(
            model_path,
            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
            device_map="auto",
            trust_remote_code=True
        )
        
        # 设置为评估模式
        model.eval()
        print("模型加载完成！")

# 启动时加载模型
@app.on_event("startup")
async def startup_event():
    load_models()

# API端点：健康检查
@app.get("/health")
async def health_check():
    return {"status": "healthy", "model_loaded": model is not None}

# API端点：聊天接口
@app.post("/chat", response_model=ChatResponse)
async def chat_completion(request: ChatRequest):
    """处理聊天请求"""
    try:
        start_time = time.time()
        
        # 准备输入
        chat_history = [{"role": msg.role, "content": msg.content} for msg in request.messages]
        
        # 应用聊天模板
        inputs = tokenizer.apply_chat_template(
            chat_history,
            add_generation_prompt=True,
            return_tensors="pt"
        )
        
        # 移动输入到正确的设备
        if torch.cuda.is_available():
            inputs = inputs.to("cuda")
        
        # 生成回复
        with torch.no_grad():
            outputs = model.generate(
                inputs,
                max_new_tokens=request.max_tokens,
                temperature=request.temperature,
                top_p=request.top_p,
                do_sample=True,
                pad_token_id=tokenizer.eos_token_id
            )
        
        # 解码回复
        response = tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)
        
        # 处理思考过程
        thinking_process = None
        final_answer = None
        
        if "<|begin_of_thought|>" in response and "<|end_of_thought|>" in response:
            parts = response.split("<|end_of_thought|>")
            thinking_part = parts[0].replace("<|begin_of_thought|>", "").strip()
            answer_part = parts[1].strip() if len(parts) > 1 else ""
            
            thinking_process = thinking_part
            final_answer = answer_part
        else:
            final_answer = response
        
        end_time = time.time()
        
        # 计算使用情况
        input_tokens = inputs.shape[1]
        output_tokens = outputs.shape[1] - input_tokens
        
        return ChatResponse(
            response=response,
            thinking_process=thinking_process,
            final_answer=final_answer,
            usage={
                "input_tokens": int(input_tokens),
                "output_tokens": int(output_tokens),
                "total_tokens": int(input_tokens + output_tokens),
                "processing_time": f"{end_time - start_time:.2f}s"
            }
        )
    
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"生成失败: {str(e)}")

# API端点：流式聊天接口
@app.post("/chat/stream")
async def chat_stream(request: ChatRequest):
    """流式聊天接口"""
    # 这里可以实现流式输出，为了简洁先返回普通响应
    response = await chat_completion(request)
    return response

if __name__ == "__main__":
    # 启动API服务
    uvicorn.run(
        app,
        host="0.0.0.0",
        port=8000,
        log_level="info"
    )

4.2 安装FastAPI依赖

运行API服务需要安装额外的包：

# 安装FastAPI和相关依赖
pip install fastapi uvicorn python-multipart

# 或者添加到requirements.txt
echo "fastapi>=0.104.0" >> requirements.txt
echo "uvicorn[standard]>=0.24.0" >> requirements.txt
echo "python-multipart>=0.0.6" >> requirements.txt

4.3 启动API服务

启动API服务也很简单：

# 启动API服务
python api_server.py

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

INFO:     Started server process [12345]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

现在API服务就在http://localhost:8000运行了。

5. 调用API的几种方式

API服务启动后，我们可以用多种方式调用它。下面我展示几种最常用的方法。

5.1 使用Python调用API

这是最直接的方式，适合在Python项目中使用：

# test_api.py
import requests
import json

# API地址
API_URL = "http://localhost:8000/chat"

# 准备请求数据
chat_data = {
    "messages": [
        {"role": "user", "content": "请用Python写一个快速排序算法"}
    ],
    "max_tokens": 1024,
    "temperature": 0.6,
    "top_p": 0.95
}

# 发送请求
try:
    response = requests.post(
        API_URL,
        json=chat_data,
        headers={"Content-Type": "application/json"},
        timeout=60  # 60秒超时
    )
    
    if response.status_code == 200:
        result = response.json()
        
        print("=== 思考过程 ===")
        if result.get("thinking_process"):
            print(result["thinking_process"])
        
        print("\n=== 最终回答 ===")
        print(result["final_answer"])
        
        print("\n=== 使用统计 ===")
        print(f"输入token数: {result['usage']['input_tokens']}")
        print(f"输出token数: {result['usage']['output_tokens']}")
        print(f"总token数: {result['usage']['total_tokens']}")
        print(f"处理时间: {result['usage']['processing_time']}")
    else:
        print(f"请求失败: {response.status_code}")
        print(response.text)

except requests.exceptions.RequestException as e:
    print(f"请求错误: {e}")
except Exception as e:
    print(f"其他错误: {e}")

5.2 使用cURL命令行调用

如果你喜欢用命令行，或者需要在脚本中调用：

# 简单的单次调用
curl -X POST "http://localhost:8000/chat" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "解释一下什么是机器学习"}
    ],
    "max_tokens": 500
  }'

# 带有多轮对话历史的调用
curl -X POST "http://localhost:8000/chat" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [
      {"role": "user", "content": "什么是Python的装饰器？"},
      {"role": "assistant", "content": "装饰器是Python中一种特殊的语法，用于修改或增强函数的行为..."},
      {"role": "user", "content": "能给我一个具体的例子吗？"}
    ],
    "temperature": 0.7
  }'

5.3 创建简单的Web前端

如果你想做个简单的网页来调用API，可以创建一个HTML文件：

<!-- chat_frontend.html -->
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>DeepSeek R1 聊天前端</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            max-width: 800px;
            margin: 0 auto;
            padding: 20px;
            background-color: #f5f5f5;
        }
        .chat-container {
            background: white;
            border-radius: 10px;
            padding: 20px;
            box-shadow: 0 2px 10px rgba(0,0,0,0.1);
        }
        .message {
            margin: 10px 0;
            padding: 10px;
            border-radius: 5px;
        }
        .user-message {
            background-color: #e3f2fd;
            text-align: right;
        }
        .assistant-message {
            background-color: #f5f5f5;
        }
        .thinking {
            background-color: #fff3e0;
            font-style: italic;
            color: #666;
        }
        #input-area {
            margin-top: 20px;
            display: flex;
            gap: 10px;
        }
        #user-input {
            flex: 1;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 5px;
        }
        button {
            padding: 10px 20px;
            background-color: #007bff;
            color: white;
            border: none;
            border-radius: 5px;
            cursor: pointer;
        }
        button:hover {
            background-color: #0056b3;
        }
    </style>
</head>
<body>
    <div class="chat-container">
        <h2>🤖 DeepSeek R1 聊天助手</h2>
        <div id="chat-history"></div>
        
        <div id="input-area">
            <input type="text" id="user-input" placeholder="输入你的问题...">
            <button onclick="sendMessage()">发送</button>
        </div>
    </div>

    <script>
        const API_URL = "http://localhost:8000/chat";
        let chatHistory = [];
        
        function addMessage(role, content, isThinking = false) {
            const chatHistoryDiv = document.getElementById('chat-history');
            const messageDiv = document.createElement('div');
            
            messageDiv.className = `message ${role}-message ${isThinking ? 'thinking' : ''}`;
            messageDiv.innerHTML = `<strong>${role === 'user' ? '你' : 'AI'}:</strong><br>${content}`;
            
            chatHistoryDiv.appendChild(messageDiv);
            chatHistoryDiv.scrollTop = chatHistoryDiv.scrollHeight;
        }
        
        async function sendMessage() {
            const input = document.getElementById('user-input');
            const message = input.value.trim();
            
            if (!message) return;
            
            // 添加用户消息
            addMessage('user', message);
            chatHistory.push({ role: 'user', content: message });
            
            // 清空输入框
            input.value = '';
            
            try {
                // 发送请求
                const response = await fetch(API_URL, {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json'
                    },
                    body: JSON.stringify({
                        messages: chatHistory,
                        max_tokens: 1024,
                        temperature: 0.6
                    })
                });
                
                if (!response.ok) {
                    throw new Error(`HTTP错误: ${response.status}`);
                }
                
                const data = await response.json();
                
                // 显示思考过程
                if (data.thinking_process) {
                    addMessage('assistant', data.thinking_process, true);
                }
                
                // 显示最终回答
                if (data.final_answer) {
                    addMessage('assistant', data.final_answer);
                }
                
                // 更新对话历史
                chatHistory.push({ role: 'assistant', content: data.response });
                
                // 显示使用统计
                const usageInfo = `[Tokens: 输入${data.usage.input_tokens} / 输出${data.usage.output_tokens} / 时间${data.usage.processing_time}]`;
                addMessage('system', usageInfo);
                
            } catch (error) {
                addMessage('system', `错误: ${error.message}`);
            }
        }
        
        // 支持回车发送
        document.getElementById('user-input').addEventListener('keypress', function(e) {
            if (e.key === 'Enter') {
                sendMessage();
            }
        });
    </script>
</body>
</html>

把这个HTML文件保存下来，用浏览器打开就能直接用了。

6. 实际应用场景示例

了解了怎么调用API，我们来看看在实际项目中怎么用。这里有几个具体的例子。

6.1 集成到Flask Web应用

如果你有一个现有的Flask应用，可以这样集成：

# flask_integration.py
from flask import Flask, request, jsonify, render_template
import requests
import json

app = Flask(__name__)

# DeepSeek API配置
DEEPSEEK_API = "http://localhost:8000/chat"

@app.route('/')
def index():
    """渲染聊天页面"""
    return render_template('chat.html')

@app.route('/api/chat', methods=['POST'])
def chat():
    """处理聊天请求"""
    try:
        data = request.json
        user_message = data.get('message', '')
        
        # 调用DeepSeek API
        response = requests.post(
            DEEPSEEK_API,
            json={
                "messages": [{"role": "user", "content": user_message}],
                "max_tokens": 1024,
                "temperature": 0.6
            },
            timeout=30
        )
        
        if response.status_code == 200:
            result = response.json()
            return jsonify({
                "success": True,
                "thinking": result.get("thinking_process", ""),
                "answer": result.get("final_answer", ""),
                "usage": result.get("usage", {})
            })
        else:
            return jsonify({
                "success": False,
                "error": "API调用失败"
            }), 500
            
    except Exception as e:
        return jsonify({
            "success": False,
            "error": str(e)
        }), 500

@app.route('/api/code-review', methods=['POST'])
def code_review():
    """代码审查功能"""
    data = request.json
    code = data.get('code', '')
    language = data.get('language', 'python')
    
    prompt = f"""请审查以下{language}代码：
{code}

请提供：
1. 代码逻辑分析
2. 潜在问题
3. 改进建议
4. 优化后的代码示例"""
    
    # 调用API进行代码审查
    response = requests.post(
        DEEPSEEK_API,
        json={
            "messages": [{"role": "user", "content": prompt}],
            "max_tokens": 2048,
            "temperature": 0.3  # 代码审查需要更确定性的输出
        }
    )
    
    if response.status_code == 200:
        result = response.json()
        return jsonify({
            "review": result.get("final_answer", ""),
            "thinking": result.get("thinking_process", "")
        })
    
    return jsonify({"error": "审查失败"}), 500

if __name__ == '__main__':
    app.run(debug=True, port=5000)

6.2 创建命令行工具

如果你喜欢用命令行，可以创建一个简单的CLI工具：

# deepseek_cli.py
import argparse
import requests
import json
import sys

class DeepSeekCLI:
    def __init__(self, api_url="http://localhost:8000"):
        self.api_url = api_url
        self.chat_history = []
    
    def chat(self, message, stream=False):
        """发送聊天消息"""
        self.chat_history.append({"role": "user", "content": message})
        
        try:
            endpoint = f"{self.api_url}/chat/stream" if stream else f"{self.api_url}/chat"
            
            response = requests.post(
                endpoint,
                json={
                    "messages": self.chat_history,
                    "max_tokens": 1024,
                    "temperature": 0.6
                },
                timeout=60
            )
            
            if response.status_code == 200:
                result = response.json()
                
                # 显示思考过程
                if result.get("thinking_process"):
                    print("\n🤔 思考过程:")
                    print("-" * 50)
                    print(result["thinking_process"])
                    print("-" * 50)
                
                # 显示最终回答
                if result.get("final_answer"):
                    print("\n💡 回答:")
                    print(result["final_answer"])
                
                # 更新对话历史
                self.chat_history.append({
                    "role": "assistant", 
                    "content": result["response"]
                })
                
                # 显示使用统计
                usage = result.get("usage", {})
                print(f"\n📊 使用统计: {usage.get('input_tokens', 0)}输入 + {usage.get('output_tokens', 0)}输出 = {usage.get('total_tokens', 0)}tokens")
                
            else:
                print(f"错误: {response.status_code}")
                print(response.text)
                
        except Exception as e:
            print(f"请求失败: {e}")
    
    def clear_history(self):
        """清空对话历史"""
        self.chat_history = []
        print("对话历史已清空")
    
    def interactive_mode(self):
        """交互式聊天模式"""
        print("DeepSeek R1 命令行聊天工具")
        print("输入 'quit' 退出，'clear' 清空历史")
        print("-" * 50)
        
        while True:
            try:
                user_input = input("\n你: ").strip()
                
                if user_input.lower() == 'quit':
                    print("再见！")
                    break
                elif user_input.lower() == 'clear':
                    self.clear_history()
                    continue
                elif user_input:
                    self.chat(user_input)
                    
            except KeyboardInterrupt:
                print("\n\n再见！")
                break
            except Exception as e:
                print(f"错误: {e}")

def main():
    parser = argparse.ArgumentParser(description="DeepSeek R1 命令行工具")
    parser.add_argument("--api", default="http://localhost:8000", help="API地址")
    parser.add_argument("--message", "-m", help="直接发送消息")
    parser.add_argument("--interactive", "-i", action="store_true", help="交互模式")
    
    args = parser.parse_args()
    
    cli = DeepSeekCLI(args.api)
    
    if args.message:
        cli.chat(args.message)
    elif args.interactive:
        cli.interactive_mode()
    else:
        parser.print_help()

if __name__ == "__main__":
    main()

使用方式：

# 交互模式
python deepseek_cli.py -i

# 单次提问
python deepseek_cli.py -m "Python中的列表和元组有什么区别？"

6.3 集成到Jupyter Notebook

如果你在Jupyter中做数据分析或机器学习，可以这样集成：

# 在Jupyter Notebook中使用
import requests
import json
from IPython.display import display, Markdown

class DeepSeekNotebook:
    def __init__(self, api_url="http://localhost:8000"):
        self.api_url = api_url
        self.history = []
    
    def ask(self, question, show_thinking=True):
        """提问并显示回答"""
        print(f"🧑‍💻 问题: {question}")
        print("-" * 50)
        
        # 准备请求
        self.history.append({"role": "user", "content": question})
        
        try:
            response = requests.post(
                f"{self.api_url}/chat",
                json={
                    "messages": self.history,
                    "max_tokens": 1024,
                    "temperature": 0.6
                },
                timeout=30
            )
            
            if response.status_code == 200:
                result = response.json()
                
                # 显示思考过程
                if show_thinking and result.get("thinking_process"):
                    print("🤔 思考过程:")
                    print(result["thinking_process"])
                    print("-" * 50)
                
                # 显示最终回答
                answer = result.get("final_answer", "")
                display(Markdown(f"**💡 回答:**\n\n{answer}"))
                
                # 更新历史
                self.history.append({
                    "role": "assistant",
                    "content": result["response"]
                })
                
                # 返回结果
                return {
                    "thinking": result.get("thinking_process"),
                    "answer": answer,
                    "usage": result.get("usage", {})
                }
            else:
                print(f"错误: {response.status_code}")
                return None
                
        except Exception as e:
            print(f"请求失败: {e}")
            return None
    
    def clear(self):
        """清空对话历史"""
        self.history = []
        print("对话历史已清空")

# 在Notebook中使用
ds = DeepSeekNotebook()

# 提问
result = ds.ask("请解释梯度下降算法的原理")

# 继续提问（保持上下文）
result2 = ds.ask("那随机梯度下降和批量梯度下降有什么区别？")

7. 总结

通过今天的学习，你应该已经掌握了如何部署和使用DeepSeek-R1-Distill-Qwen-1.5B这个超轻量的本地AI助手。我们来回顾一下重点：

7.1 核心收获

1. 全本地部署：你学会了如何在自己的机器上部署这个AI模型，完全不需要依赖云端服务，数据隐私有保障。

2. 双模式使用：不仅可以通过Streamlit的Web界面直接聊天，还能通过API接口在其他项目中调用AI能力。

3. 灵活集成：我展示了多种集成方式——Python脚本、命令行工具、Web应用、Jupyter Notebook，你可以根据需求选择最适合的方式。

4. 实际应用：这个模型特别适合需要逻辑推理的场景，比如代码审查、数学解题、逻辑分析等，而且它的思考过程可视化功能让AI的“思考”变得透明。

7.2 使用建议

根据我的使用经验，给你几个实用建议：

• 硬件选择：如果有GPU，尽量用GPU运行，速度会快很多。没有GPU的话，CPU也能用，只是稍微慢一点。

• 参数调整：如果你需要更确定的回答（比如代码生成），可以把temperature调低到0.3-0.5；如果需要更多创意，可以调到0.7-0.9。

• 对话管理：长时间对话后，记得点击清空按钮或者调用清空接口，避免显存占用过多。

• 错误处理：在实际应用中，记得添加适当的错误处理和超时机制，确保服务稳定性。

7.3 下一步探索

如果你对这个方案感兴趣，还可以尝试：

1. 性能优化：尝试量化模型，进一步降低显存占用
2. 功能扩展：添加文件上传、图片理解等更多功能
3. 部署优化：用Docker容器化部署，方便迁移和扩展
4. 监控集成：添加使用统计、性能监控等功能

这个项目的最大优势就是灵活——你可以在自己的电脑上快速搭建一个私有AI助手，然后通过各种方式调用它。无论是个人学习、项目开发，还是企业内部工具，都能找到用武之地。

---

获取更多AI镜像

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