Qwen2.5-72B-GPTQ-Int4实操手册：Chainlit+LangChain工作流集成示例

本文介绍了如何在星图GPU平台上自动化部署Qwen2.5-72B-Instruct-GPTQ-Int4镜像，并快速构建一个集成了Chainlit前端与LangChain框架的AI对话应用。该方案通过量化技术降低了硬件门槛，用户可轻松搭建智能助手，应用于代码生成、文档问答等场景，显著提升开发与内容创作效率。

电竞小潘安

126人浏览 · 2026-04-07 05:34:53

电竞小潘安 · 2026-04-07 05:34:53 发布

Qwen2.5-72B-GPTQ-Int4实操手册：Chainlit+LangChain工作流集成示例

想体验720亿参数大模型的强大推理能力，又担心硬件成本太高？Qwen2.5-72B-Instruct-GPTQ-Int4模型提供了一个完美的解决方案。通过GPTQ 4-bit量化技术，这个原本需要大量显存的庞然大物，现在可以在消费级显卡上流畅运行。

今天，我将带你一步步搭建一个完整的AI对话系统。我们将使用vLLM部署Qwen2.5-72B-Instruct-GPTQ-Int4模型，然后用Chainlit构建一个美观的Web前端，最后通过LangChain构建一个智能工作流。整个过程就像搭积木一样简单，即使你是AI部署的新手，也能轻松完成。

1. 环境准备与模型部署

1.1 理解我们的技术栈

在开始之前，我们先简单了解一下要用到的几个关键组件：

Qwen2.5-72B-Instruct-GPTQ-Int4：这是今天的主角，一个720亿参数的大语言模型，经过指令微调和4-bit量化，能在有限的硬件资源下提供强大的文本生成能力。
vLLM：一个高效的大语言模型推理引擎，专门为高吞吐量、低延迟的模型服务而设计。
Chainlit：一个专门为AI应用设计的UI框架，可以快速构建出类似ChatGPT的交互界面。
LangChain：一个用于构建大语言模型应用的框架，可以帮助我们组织复杂的对话流程和工作流。

1.2 检查模型服务状态

模型部署完成后，我们需要确认服务是否正常运行。打开终端，执行以下命令查看日志：

cat /root/workspace/llm.log

如果看到类似下面的输出，说明模型已经成功加载并准备好接收请求了：

INFO 07-28 14:30:15 llm_engine.py:73] Initializing an LLM engine with config: model='/root/workspace/models/Qwen2.5-72B-Instruct-GPTQ-Int4', tokenizer='/root/workspace/models/Qwen2.5-72B-Instruct-GPTQ-Int4', tokenizer_mode=auto, trust_remote_code=True, dtype=torch.float16, ...
INFO 07-28 14:30:15 llm_engine.py:175] # GPU blocks: 14528, # CPU blocks: 2048
INFO 07-28 14:30:15 model_runner.py:474] Loading weights from /root/workspace/models/Qwen2.5-72B-Instruct-GPTQ-Int4
INFO 07-28 14:30:45 llm_engine.py:221] KV cache usage: 0.0%
INFO 07-28 14:30:45 llm_engine.py:222] Ready to process requests

这里有几个关键信息需要注意：

模型路径：确认模型正确加载自指定目录
GPU内存分配：显示了显存块的使用情况
KV缓存：显示了键值缓存的当前使用率，0%表示还没有处理请求
就绪状态：最后一行显示"Ready to process requests"，这是最重要的成功标志

如果服务没有正常启动，常见的问题包括：

模型文件路径不正确
显存不足（虽然用了4-bit量化，72B模型仍然需要相当的显存）
端口被占用
依赖包版本冲突

2. Chainlit前端快速上手

2.1 启动Chainlit界面

模型服务运行正常后，我们就可以启动前端界面了。Chainlit提供了一个非常直观的Web界面，让用户可以通过浏览器直接与模型交互。

启动Chainlit服务通常只需要一个简单的命令：

chainlit run app.py

启动成功后，你会在终端看到类似这样的输出：

Chainlit app is running at http://localhost:8000

现在，打开浏览器，访问 http://localhost:8000，就能看到一个干净、现代的聊天界面。界面通常分为三个主要区域：

左侧：对话历史列表
中间：主聊天区域，显示对话内容
右侧：设置面板，可以调整模型参数

2.2 进行第一次对话测试

让我们从简单的问题开始，测试模型的基本功能。在Chainlit的输入框中，尝试问一些基础问题：

你好，请介绍一下你自己。

模型应该会回复类似这样的内容：

你好！我是Qwen2.5，一个由阿里云开发的大语言模型。我基于720亿参数的架构构建，支持多种语言，包括中文、英文等。我擅长文本生成、代码编写、问题解答、创意写作等多种任务。我的上下文长度支持达到128K tokens，可以处理较长的对话和文档。

我经过了大量的预训练和指令微调，在编程、数学、逻辑推理等方面有较好的表现。同时，我支持生成结构化输出（如JSON格式），能够更好地与应用程序集成。

有什么我可以帮助你的吗？

这个回复展示了模型的几个关键能力：

自我认知：清楚知道自己的身份和能力范围
多语言支持：明确提到支持中文、英文等多种语言
功能说明：列出了文本生成、代码编写等核心能力
技术参数：提到了128K上下文长度等重要特性
结构化输出：强调了JSON格式支持，这对开发集成很重要

2.3 测试模型的核心能力

为了全面了解模型的性能，我们可以设计几个不同类型的测试问题：

测试1：代码生成能力

请用Python写一个快速排序算法的实现，并添加详细的注释说明每一步的作用。

测试2：逻辑推理能力

如果所有的猫都怕水，而Tom是一只猫，那么Tom怕水吗？请解释你的推理过程。

测试3：长文本处理

请总结《红楼梦》前五回的主要情节，每个回目用100字左右概括。

测试4：结构化输出

请以JSON格式返回北京、上海、广州三个城市的人口数量和GDP数据。

通过这些测试，你可以评估模型在不同场景下的表现。Qwen2.5-72B模型在这些任务上通常会有不错的表现，特别是在代码生成和逻辑推理方面。

3. LangChain工作流集成实战

3.1 基础LangChain集成

现在让我们把模型集成到LangChain框架中。LangChain提供了更灵活的方式来构建复杂的AI应用。首先，我们需要创建一个基本的LangChain链：

from langchain.llms import VLLM
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# 初始化vLLM模型
llm = VLLM(
    model="/root/workspace/models/Qwen2.5-72B-Instruct-GPTQ-Int4",
    trust_remote_code=True,
    max_new_tokens=1024,
    temperature=0.7,
    top_p=0.95,
)

# 创建提示模板
prompt_template = PromptTemplate(
    input_variables=["question"],
    template="你是一个有帮助的AI助手。请回答以下问题：\n\n问题：{question}\n\n回答："
)

# 创建链
chain = LLMChain(llm=llm, prompt=prompt_template)

# 使用链进行推理
question = "什么是机器学习？"
response = chain.run(question)
print(response)

这段代码做了几件事：

初始化模型：通过VLLM类连接到我们部署的模型
设置参数：配置了生成长度、温度等关键参数
创建模板：定义了一个简单的提示模板
构建链：将模型和模板组合成一个可执行的链
执行推理：运行链并获取结果

3.2 构建复杂工作流

LangChain的真正威力在于构建复杂的工作流。让我们创建一个更实用的例子——一个文档问答系统：

from langchain.document_loaders import TextLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA

# 1. 加载文档
loader = TextLoader("document.txt")
documents = loader.load()

# 2. 分割文档
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
texts = text_splitter.split_documents(documents)

# 3. 创建向量数据库
embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
vectorstore = FAISS.from_documents(texts, embeddings)

# 4. 创建检索器
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# 5. 创建问答链
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True
)

# 6. 提问
query = "文档中提到了哪些关键技术？"
result = qa_chain({"query": query})
print("答案：", result["result"])
print("\n参考来源：")
for doc in result["source_documents"]:
    print(f"- {doc.page_content[:100]}...")

这个工作流展示了LangChain的几个核心概念：

文档加载：从文件系统加载文本内容
文本分割：将长文档切分成适合处理的片段
向量化：将文本转换为数值向量
相似度检索：根据问题找到最相关的文档片段
生成答案：基于检索到的内容生成最终答案

3.3 集成Chainlit的完整应用

最后，让我们把Chainlit和LangChain结合起来，创建一个完整的Web应用：

import chainlit as cl
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory

@cl.on_chat_start
async def start():
    # 初始化对话链
    memory = ConversationBufferMemory()
    chain = ConversationChain(
        llm=llm,
        memory=memory,
        verbose=True
    )
    
    # 保存到用户会话
    cl.user_session.set("chain", chain)
    
    # 发送欢迎消息
    await cl.Message(
        content="你好！我是基于Qwen2.5-72B模型的AI助手。我可以帮你解答问题、编写代码、分析文档等。有什么可以帮你的吗？"
    ).send()

@cl.on_message
async def main(message: cl.Message):
    # 获取对话链
    chain = cl.user_session.get("chain")
    
    # 调用模型
    response = await chain.arun(
        message.content,
        callbacks=[cl.AsyncLangchainCallbackHandler()]
    )
    
    # 发送回复
    await cl.Message(content=response).send()

这个完整的应用提供了：

会话记忆：能够记住之前的对话内容
实时交互：用户输入后立即得到响应
状态管理：在用户会话中保存对话状态
回调处理：集成LangChain的回调系统

4. 高级功能与优化技巧

4.1 性能优化配置

为了让模型运行得更快、更稳定，我们可以调整一些关键参数：

# 优化后的模型配置
llm = VLLM(
    model="/root/workspace/models/Qwen2.5-72B-Instruct-GPTQ-Int4",
    trust_remote_code=True,
    max_new_tokens=2048,  # 增加生成长度
    temperature=0.3,      # 降低随机性，使输出更确定
    top_p=0.9,           # 核采样参数
    top_k=50,            # Top-K采样
    repetition_penalty=1.1,  # 重复惩罚
    stop=["\n\n", "###"],    # 停止词
    gpu_memory_utilization=0.9,  # GPU内存利用率
    tensor_parallel_size=2,      # 张量并行，如果有多GPU
)

参数说明：

temperature：控制输出的随机性，值越低输出越确定
top_p：核采样，只考虑累积概率达到该值的token
top_k：只从概率最高的k个token中采样
repetition_penalty：惩罚重复内容，避免循环
gpu_memory_utilization：合理设置可以避免内存溢出

4.2 处理长文本对话

Qwen2.5支持128K的上下文长度，我们可以利用这个特性处理长文档：

from langchain.chains import AnalyzeDocumentChain
from langchain.chains.summarize import load_summarize_chain

# 创建文档分析链
summary_chain = load_summarize_chain(llm, chain_type="map_reduce")

analyze_chain = AnalyzeDocumentChain(
    combine_docs_chain=summary_chain,
    text_splitter=text_splitter
)

# 处理长文档
with open("long_document.txt", "r", encoding="utf-8") as f:
    long_text = f.read()

summary = analyze_chain.run(long_text)
print("文档摘要：", summary)

处理长文本的技巧：

分块处理：将长文档分成多个片段
Map-Reduce策略：先总结每个片段，再总结所有片段的总结
增量处理：对于超长文档，可以分批处理
关键信息提取：先提取关键信息，再基于关键信息生成总结

4.3 错误处理与监控

在实际应用中，良好的错误处理机制是必不可少的：

import logging
from typing import Optional

class RobustQAChain:
    def __init__(self, llm, retriever):
        self.llm = llm
        self.retriever = retriever
        self.logger = logging.getLogger(__name__)
    
    async def answer_question(self, question: str) -> Optional[str]:
        try:
            # 尝试检索相关文档
            docs = self.retriever.get_relevant_documents(question)
            
            if not docs:
                self.logger.warning(f"未找到与问题相关的文档：{question}")
                return "抱歉，我没有找到相关的信息来回答这个问题。"
            
            # 构建提示
            context = "\n\n".join([doc.page_content for doc in docs[:3]])
            prompt = f"基于以下信息回答问题：\n\n{context}\n\n问题：{question}\n\n回答："
            
            # 调用模型
            response = await self.llm.apredict(prompt)
            
            return response
            
        except Exception as e:
            self.logger.error(f"处理问题时出错：{str(e)}")
            return "抱歉，处理您的问题时出现了错误。请稍后再试或尝试重新提问。"

错误处理策略：