DeepSeek-R1 蒸馏版接入 LangChain

LangChain 的价值在接口统一：链、提示模板、智能体都是同一套用法，底下换成什么模型都不影响上层代码。这意味着你可以先在本地小模型上把整个应用调通，之后再平滑换到更大的模型，应用代码一行不改。想让本地部署的 DeepSeek-R1-Distill-Qwen-7B 进入这套体系，只需要写一个很小的适配类。这篇把它写出来，顺便解决推理模型特有的问题——把思考过程和最终回答分开。全文核心就是一个类加一个函数，写完之后你的本地模型就拥有了和云端模型一样的接入面：提示模板、输出解析、链式调用都能直接用。

环境和模型

参考环境：Ubuntu 22.04、Python 3.12、CUDA 12.1、PyTorch 2.3.0，PyTorch 的 CUDA 环境要提前装好 ^[1]。依赖全部锁版本，走清华镜像源安装——langchain 0.3.17 配 transformers 4.48.2 ^[1]：

# 升级pip
python -m pip install --upgrade pip
# 更换 pypi 源加速库的安装
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

pip install transformers==4.48.2
pip install huggingface-hub==0.28.1
pip install accelerate==1.3.0
pip install modelscope==1.22.3
pip install langchain==0.3.17

版本锁定在这一步尤其重要：langchain 迭代很快，API 在小版本之间就有变动，照抄下面这组版本组合可以避开大部分兼容性问题。模型用 modelscope 的 snapshot_download 下载，第一个参数是模型名，cache_dir 是下载路径 ^[1]：

from modelscope import snapshot_download

model_dir = snapshot_download('deepseek-ai/DeepSeek-R1-Distill-Qwen-7B', cache_dir='/root/autodl-tmp', revision='master')

写适配类

接入方法是继承 LangChain.llms.base.LLM 写一个子类，只重写两处：构造函数和 _call 函数 ^[1]。这个适配层职责很清晰：构造函数管「把模型装进内存」，_call 管「把字符串变成模型调用再变回字符串」——LangChain 关心的只有这两件事。写完之后，LangChain 的所有接口都能用完全一致的方式调用这个模型，不用管底层模型调用的差异 ^[1]。前半段负责加载模型 ^[1]：

from langchain.llms.base import LLM
from typing import Any, List, Optional
from langchain.callbacks.manager import CallbackManagerForLLMRun
from transformers import AutoTokenizer, AutoModelForCausalLM, GenerationConfig
import torch

class DeepSeek_R1_Distill_Qwen_LLM(LLM):
    # 基于本地 DeepSeek_R1_Distill_Qwen 自定义 LLM 类
    tokenizer: AutoTokenizer = None
    model: AutoModelForCausalLM = None
      
    def __init__(self, mode_name_or_path :str):

        super().__init__()
        print("正在从本地加载模型...")
        self.tokenizer = AutoTokenizer.from_pretrained(mode_name_or_path, use_fast=False)
        self.model = AutoModelForCausalLM.from_pretrained(mode_name_or_path, torch_dtype=torch.bfloat16, device_map="auto")
        self.model.generation_config = GenerationConfig.from_pretrained(mode_name_or_path)
        print("完成本地模型的加载")

模型在构造函数里加载，一次实例化只加载一次，避免每次调用都重新加载模型带来的漫长等待——这个设计对 LangChain 的链式场景尤其重要：链里可能一秒内调用模型十几次，每次都加载磁盘上的权重是完全不可行的；权重用 bfloat16 精度，device_map 设为 auto 让框架自己安排显卡 ^[1]。三个加载细节值得展开：bfloat16 是推理模型常用精度，比 fp32 省一半以上显存，数值精度损失可忽略；device_map="auto" 依赖 accelerate 库（上面已安装），它会把模型层自动分配到可用设备上，多卡也能自动切分；generation_config 从模型目录读取，里面带着模型官方推荐的一组生成参数，跟着走最稳。后半段是 _call——LangChain 调用模型的入口 ^[1]：

    def _call(self, prompt : str, stop: Optional[List[str]] = None,
                run_manager: Optional[CallbackManagerForLLMRun] = None,
                **kwargs: Any):

        messages = [{"role": "user", "content": prompt }]
        input_ids = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
        model_inputs = self.tokenizer([input_ids], return_tensors="pt").to('cuda')
        generated_ids = self.model.generate(model_inputs.input_ids, attention_mask=model_inputs['attention_mask'], max_new_tokens=8192) # 思考需要输出更多的Token数，设为8K
        generated_ids = [
            output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
        ]
        response = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
      
        return response
    @property
    def _llm_type(self) -> str:
        return "DeepSeek_R1_Distill_Qwen_LLM"

_call 里的流程：prompt 先包装成 user 消息，过一遍聊天模板（apply_chat_template 负责把消息转成模型训练时见过的格式，这一步不做，输出质量会明显下降）；tokenize 后送进 generate，max_new_tokens 设 8192——思考需要输出更多 token；生成的序列要按输入长度切片，只保留新生成部分，最后 batch_decode 解码，skip_special_tokens=True 把特殊标记丢掉 ^[1]。use_fast=False 表示加载慢速分词器，某些模型的分词器对快速实现支持不全，跟官方用法保持一致最稳。文件存成 LLM.py，项目里直接从这个文件引入自定义的 LLM 类 ^[1]。这个文件之后就成了模型和框架之间的唯一边界：模型升级、路径变更，都只改这一个文件。

调用与思考内容分离

之后就可以像使用任何其他 LangChain 大模型一样使用它：传入自己的模型路径实例化，然后用普通字符串调用 ^[1]。调用方式看起来朴素，但注意实例化的时机——模型加载要花几十秒，应该在应用启动时实例化一次并复用，而不是每个请求新建一个实例；

from LLM import DeepSeek_R1_Distill_Qwen_LLM
import re

# 文本分割函数
def split_text(text):
    pattern = re.compile(r'<think>(.*?)</think>(.*)', re.DOTALL) # 定义正则表达式模式
    match = pattern.search(text) # 匹配 <think>思考过程</think>回答
  
    if match: # 如果匹配到思考过程
        think_content = match.group(1).strip() # 获取思考过程
        answer_content = match.group(2).strip() # 获取回答
    else:
        think_content = "" # 如果没有匹配到思考过程，则设置为空字符串
        answer_content = text.strip() # 直接返回回答
  
    return think_content, answer_content
  
llm = DeepSeek_R1_Distill_Qwen_LLM(mode_name_or_path = "/root/autodl-tmp/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B")

response = llm("我如何为我学习Python制定目标？")
think, answer = split_text(response) # 调用split_text函数，分割思考过程和回答
print(f"{"-"*20}思考{"-"*20}")
print(think) # 输出思考
print(f"{"-"*20}回答{"-"*20}")
print(answer) # 输出回答

split_text 这个函数值得在所有推理模型项目里备一份：原始响应里，思考过程包在 <think> 和 </think> 标签之间，正则把两部分拆出来；没匹配到思考块时走兜底分支，直接把全文当回答返回 ^[1]。把思考和回答分开打印，排查问题时一眼能看出错在推理环节还是知识环节。实际项目里还可以再往前一步：把 think 写进日志、answer 返回给用户，前端就能只展示结论，想看推理过程的人再去翻日志。

接进链里

适配类写完只是第一步，真正省事的是它后面的组合能力。判断要不要接 LangChain，就看应用会不会长出这些需求：换模型、拼模板、串链路。只要中了一条，这半小时就值得花。最简单的用法是套一个提示模板：

• 用 LangChain 的提示模板把「领域指令 + 用户输入」拼成完整 prompt，再传给这个 LLM 类；
• 多个调用串成链时，上一环的输出直接作为下一环的输入，模型替换不影响链的结构；
• 需要结构化输出时，在 prompt 里约定格式，配合正则或解析器提取。

这套组合让「换模型」变成一行构造参数的事，这也是值得花半小时写适配类的原因。

常见问题

1. 加载报错提示缺 accelerate。device_map="auto" 依赖 accelerate，确认它装上了且版本不旧；
2. 显存吃紧。bfloat16 下的 7B 权重已经比较紧凑，吃紧时优先缩短 max_new_tokens、关掉其他占卡的进程；
3. 回答被截断。思考过程长的题目会顶到 max_new_tokens 上限，适当调大或换更短的问题验证；
4. split_text 匹配不到。部分输出可能没有 <think> 标签，兜底分支会生效，但如果频繁出现，检查聊天模板的 add_generation_prompt 参数是否传了 True。

本文改编自 Datawhale 开源教程《self-llm》的 DeepSeek-R1-Distill-Qwen-7B Langchain 接入一节^[1]，原文以 Apache-2.0 许可证发布。