开箱即用：GLM-4-9B-Chat-1M快速部署与API封装指南

开箱即用：GLM-4-9B-Chat-1M快速部署与API封装指南

你是否遇到过这样的场景？手头有一份300页的PDF合同需要快速总结，或者需要让AI帮你分析一整年的财报数据，但大多数模型一看到长文档就“内存爆炸”，要么直接报错，要么生成的内容牛头不对马嘴。

今天要介绍的GLM-4-9B-Chat-1M，就是专门为解决这类长文本处理难题而生的。它最大的特点就是“能装”——一次性能处理100万个token，相当于200万汉字。这意味着你可以把一本中等厚度的书直接扔给它，让它帮你总结、分析、问答。

更让人惊喜的是，这个“大胃王”对硬件的要求并不苛刻。经过INT4量化后，只需要9GB显存就能跑起来，一张RTX 3090显卡就足够了。这对于很多中小团队和个人开发者来说，是个实实在在的好消息。

本文将带你从零开始，一步步完成GLM-4-9B-Chat-1M的部署，并把它封装成稳定可用的API服务。无论你是想搭建自己的智能文档助手，还是为企业内部构建长文本分析工具，这篇文章都能给你清晰的指引。

1. 为什么选择GLM-4-9B-Chat-1M？

在开始动手之前，我们先搞清楚这个模型到底有什么特别之处。市面上支持长文本的模型不少，但GLM-4-9B-Chat-1M在几个关键点上做得相当出色。

1.1 真正的“开箱即用”长文本能力

很多模型虽然标榜支持长上下文，但实际用起来会发现各种限制。要么是推理速度慢得让人抓狂，要么是长文本下的回答质量明显下降。

GLM-4-9B-Chat-1M在这方面做了专门优化。它在LongBench-Chat评测中拿到了7.82的高分，这个分数在同尺寸模型中处于领先位置。更重要的是，在经典的“大海捞针”测试中，即使在100万token的长度下，它依然能100%准确地找到关键信息。

这意味着什么？意味着你可以放心地把长文档交给它，不用担心它会“看”了后面忘了前面。

1.2 硬件友好的部署方案

大模型部署最头疼的就是硬件要求。动辄需要A100、H100这样的专业卡，让很多团队望而却步。

GLM-4-9B-Chat-1M的官方INT4量化版本，把显存需求降到了9GB。这个数字很关键——RTX 3090的显存正好是24GB，跑这个模型绰绰有余。即使是RTX 4090，也能轻松应对。

而且官方提供了多种推理方案：Transformers、vLLM、llama.cpp GGUF，总有一款适合你的环境。

1.3 丰富的内置功能

这个模型不只是个“聊天机器人”，它内置了很多实用功能：

• 多轮对话：能记住之前的对话内容，进行连贯交流
• 代码执行：可以运行Python代码，帮你计算、分析数据
• 工具调用：支持自定义函数调用，扩展性很强
• 长文本处理模板：内置了总结、信息抽取、对比阅读等模板

这些功能都是开箱即用的，不需要你额外写很多代码。

2. 环境准备与快速部署

好了，理论部分讲得差不多了，现在开始动手。我们先从最简单的部署方式开始。

2.1 硬件和软件要求

在开始之前，确认一下你的环境是否符合要求：

硬件要求：

• GPU：NVIDIA显卡，显存≥9GB（推荐RTX 3090/4090）
• 内存：≥16GB
• 磁盘空间：≥20GB（用于存放模型文件）

软件要求：

• 操作系统：Linux（Ubuntu 20.04+）或 Windows（WSL2）
• Python：3.10+
• CUDA：11.8+

2.2 一键部署方案

如果你不想折腾环境配置，最简单的方法就是使用预置的Docker镜像。这里以CSDN星图镜像为例：

# 拉取镜像 docker pull registry.cn-hangzhou.aliyuncs.com/csdn_mirror/glm-4-9b-chat-1m:latest # 运行容器 docker run -d \ --name glm-4-9b \ --gpus all \ -p 7860:7860 \ -p 8888:8888 \ registry.cn-hangzhou.aliyuncs.com/csdn_mirror/glm-4-9b-chat-1m:latest

等待几分钟，服务启动后，你可以通过两种方式访问：

1. Web界面：打开浏览器，访问http://你的服务器IP:7860
2. Jupyter Notebook：访问http://你的服务器IP:8888

登录信息：

• 账号：kakajiang@kakajiang.com
• 密码：kakajiang

2.3 手动部署方案

如果你想更深入地了解部署过程，或者有定制化需求，可以按照下面的步骤手动部署。

首先创建虚拟环境并安装依赖：

# 创建虚拟环境 conda create -n glm-4-9b python=3.10 -y conda activate glm-4-9b # 安装PyTorch（根据你的CUDA版本选择） pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 安装模型相关依赖 pip install transformers==4.44.2 pip install sentencepiece==0.1.99 pip install accelerate==0.24.1 pip install bitsandbytes==0.41.1

然后下载并加载模型：

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig import torch # 配置4位量化 bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4" ) # 加载模型和分词器 model = AutoModelForCausalLM.from_pretrained( "THUDM/glm-4-9b-chat-1m", quantization_config=bnb_config, device_map="auto", trust_remote_code=True ) tokenizer = AutoTokenizer.from_pretrained( "THUDM/glm-4-9b-chat-1m", trust_remote_code=True )

现在模型已经加载好了，我们来测试一下：

# 准备对话 messages = [ {"role": "user", "content": "你好，请介绍一下你自己。"} ] # 应用聊天模板 inputs = tokenizer.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_tensors="pt", return_dict=True ).to("cuda") # 生成回复 with torch.no_grad(): outputs = model.generate( **inputs, max_length=1024, temperature=0.95, top_p=0.7 ) # 解码输出 response = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True) print(response)

如果一切顺利，你应该能看到模型返回的自我介绍。

3. 基础API封装

模型跑起来只是第一步，我们还需要把它封装成API服务，这样才能方便地在其他系统中调用。

3.1 使用FastAPI创建基础服务

FastAPI是个很好的选择，它性能好、文档自动生成，而且用起来简单。我们先创建一个最基础的API服务：

from fastapi import FastAPI, HTTPException from pydantic import BaseModel import torch import time import uuid from typing import Optional app = FastAPI( title="GLM-4-9B-Chat-1M API", description="支持100万token上下文的对话模型API", version="1.0.0" ) # 定义请求和响应模型 class ChatRequest(BaseModel): prompt: str max_length: Optional[int] = 1024 temperature: Optional[float] = 0.95 top_p: Optional[float] = 0.7 system_prompt: Optional[str] = None class ChatResponse(BaseModel): response: str request_id: str time_cost: float tokens_used: int # 全局模型实例（简单示例，生产环境需要优化） model = None tokenizer = None @app.on_event("startup") async def startup_event(): """启动时加载模型""" global model, tokenizer print("正在加载模型...") # 这里复用之前的手动部署代码 from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig bnb_config = BitsAndBytesConfig( load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=True, bnb_4bit_quant_type="nf4" ) model = AutoModelForCausalLM.from_pretrained( "THUDM/glm-4-9b-chat-1m", quantization_config=bnb_config, device_map="auto", trust_remote_code=True ) tokenizer = AutoTokenizer.from_pretrained( "THUDM/glm-4-9b-chat-1m", trust_remote_code=True ) print("模型加载完成！") @app.post("/chat", response_model=ChatResponse) async def chat(request: ChatRequest): """处理聊天请求""" try: start_time = time.time() request_id = str(uuid.uuid4()) # 构建消息列表 messages = [] if request.system_prompt: messages.append({"role": "system", "content": request.system_prompt}) messages.append({"role": "user", "content": request.prompt}) # 应用聊天模板 inputs = tokenizer.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_tensors="pt", return_dict=True ).to("cuda") # 生成回复 with torch.no_grad(): outputs = model.generate( **inputs, max_new_tokens=request.max_length, temperature=request.temperature, top_p=request.top_p, do_sample=True ) # 解码并计算token使用量 response_tokens = outputs[0][inputs['input_ids'].shape[1]:] response = tokenizer.decode(response_tokens, skip_special_tokens=True) tokens_used = len(response_tokens) time_cost = time.time() - start_time return ChatResponse( response=response, request_id=request_id, time_cost=round(time_cost, 3), tokens_used=tokens_used ) except Exception as e: raise HTTPException(status_code=500, detail=f"生成失败: {str(e)}") @app.get("/health") async def health_check(): """健康检查接口""" return {"status": "healthy", "model": "GLM-4-9B-Chat-1M"}

保存为main.py，然后用下面的命令启动服务：

# 安装FastAPI和Uvicorn pip install fastapi uvicorn # 启动服务 uvicorn main:app --host 0.0.0.0 --port 8000 --reload

现在访问http://localhost:8000/docs就能看到自动生成的API文档，可以直接在页面上测试接口。

3.2 测试API服务

让我们写个简单的测试脚本：

import requests import json # API地址 url = "http://localhost:8000/chat" # 测试数据 test_data = { "prompt": "请用中文总结一下机器学习的主要应用领域，每个领域举一个例子。", "max_length": 500, "temperature": 0.7 } # 发送请求 response = requests.post(url, json=test_data) if response.status_code == 200: result = response.json() print(f"请求ID: {result['request_id']}") print(f"耗时: {result['time_cost']}秒") print(f"使用Token数: {result['tokens_used']}") print(f"\n回复内容:\n{result['response']}") else: print(f"请求失败: {response.status_code}") print(response.text)

4. 性能优化与生产级部署

基础API跑起来后，我们需要考虑生产环境的需求。单线程、无缓存、无监控的服务是不能上生产环境的。

4.1 使用vLLM加速推理

vLLM是专门为大模型推理优化的库，能显著提升吞吐量。我们先安装vLLM：

pip install vllm

然后改造我们的API服务：

from vllm import LLM, SamplingParams from fastapi import FastAPI from pydantic import BaseModel import time import uuid app = FastAPI() # 初始化vLLM llm = LLM( model="THUDM/glm-4-9b-chat-1m", tensor_parallel_size=1, # 单GPU gpu_memory_utilization=0.85, max_num_batched_tokens=8192, trust_remote_code=True, quantization="awq", # 使用AWQ量化，性能更好 dtype="float16" ) class VLLMChatRequest(BaseModel): prompt: str max_tokens: int = 1024 temperature: float = 0.7 top_p: float = 0.8 @app.post("/v1/chat/completions") async def chat_completion(request: VLLMChatRequest): """使用vLLM的聊天补全接口""" start_time = time.time() # 配置生成参数 sampling_params = SamplingParams( temperature=request.temperature, top_p=request.top_p, max_tokens=request.max_tokens ) # 构建消息 messages = [{"role": "user", "content": request.prompt}] # 生成回复 outputs = llm.generate( prompts=[messages], # vLLM支持直接传入消息列表 sampling_params=sampling_params, use_tqdm=False ) # 提取结果 generated_text = outputs[0].outputs[0].text time_cost = time.time() - start_time return { "id": f"chatcmpl-{uuid.uuid4()}", "object": "chat.completion", "created": int(time.time()), "model": "glm-4-9b-chat-1m", "choices": [{ "index": 0, "message": { "role": "assistant", "content": generated_text }, "finish_reason": "stop" }], "usage": { "prompt_tokens": outputs[0].prompt_token_ids, "completion_tokens": outputs[0].outputs[0].token_ids, "total_tokens": outputs[0].prompt_token_ids + len(outputs[0].outputs[0].token_ids) }, "time_cost": round(time_cost, 3) }

vLLM的优势很明显：

• 吞吐量高：能同时处理多个请求
• 内存效率高：使用PagedAttention技术，减少内存碎片
• 兼容性好：接口设计兼容OpenAI API标准

4.2 添加缓存机制

对于相同的提问，我们没必要每次都重新生成。添加缓存可以显著提升响应速度：

from functools import lru_cache import hashlib class ChatService: def __init__(self): self.llm = LLM(...) # 初始化vLLM @lru_cache(maxsize=1000) def _get_cache_key(self, prompt: str, max_tokens: int, temperature: float, top_p: float) -> str: """生成缓存键""" content = f"{prompt}_{max_tokens}_{temperature}_{top_p}" return hashlib.md5(content.encode()).hexdigest() async def generate_with_cache(self, prompt: str, **kwargs): """带缓存的生成""" cache_key = self._get_cache_key(prompt, kwargs.get('max_tokens', 1024), kwargs.get('temperature', 0.7), kwargs.get('top_p', 0.8)) # 这里可以连接Redis等外部缓存 # cached = redis.get(cache_key) # if cached: # return cached # 实际生成 result = await self._generate(prompt, **kwargs) # 保存到缓存 # redis.setex(cache_key, 3600, result) # 缓存1小时 return result async def _generate(self, prompt: str, **kwargs): """实际生成逻辑""" # ... 生成代码 ... pass

4.3 生产环境部署配置

对于生产环境，我们需要更稳定的服务。使用Gunicorn配合多个工作进程：

# gunicorn_config.py import multiprocessing # 工作进程数，通常设置为CPU核心数*2+1 workers = multiprocessing.cpu_count() * 2 + 1 # 工作进程类型 worker_class = "uvicorn.workers.UvicornWorker" # 绑定地址 bind = "0.0.0.0:8000" # 超时设置 timeout = 120 # 日志配置 accesslog = "-" errorlog = "-" loglevel = "info" # 最大请求数，防止内存泄漏 max_requests = 1000 max_requests_jitter = 50

启动命令：

gunicorn -c gunicorn_config.py main:app

5. 长文本处理实战

GLM-4-9B-Chat-1M的核心优势就是处理长文本。我们来看看具体怎么用。

5.1 处理长文档总结

假设你有一个很长的技术文档，想要快速了解主要内容：

def summarize_long_document(document_text: str, max_summary_length: int = 500): """总结长文档""" # 如果文档太长，可以分段处理 max_chunk_size = 50000 # 每个分块约5万字 chunks = [] for i in range(0, len(document_text), max_chunk_size): chunk = document_text[i:i + max_chunk_size] chunks.append(chunk) summaries = [] for chunk in chunks: prompt = f"""请总结以下文本的主要内容，要求： 1. 提取核心观点 2. 保留关键数据和技术细节 3. 用简洁的语言表达 文本内容： {chunk} 总结：""" # 调用API获取分块总结 response = chat_with_model(prompt, max_length=200) summaries.append(response) # 如果有多段总结，可以再做一个整体总结 if len(summaries) > 1: combined_summary = "\n\n".join(summaries) final_prompt = f"""以下是文档各部分的总结，请生成一个完整的总体总结： {combined_summary} 总体总结：""" final_summary = chat_with_model(final_prompt, max_length=max_summary_length) return final_summary return summaries[0] if summaries else ""

5.2 信息抽取示例

从长文档中提取结构化信息：

def extract_contract_info(contract_text: str): """从合同文本中提取关键信息""" prompt = f"""请从以下合同文本中提取关键信息，以JSON格式返回： 需要提取的信息包括： 1. 合同双方名称 2. 合同金额 3. 合同期限 4. 付款方式 5. 违约责任条款 6. 争议解决方式 合同文本： {contract_text[:20000]} # 先处理前2万字 请返回JSON格式： {{ "parties": [], "amount": "", "duration": "", "payment_terms": "", "liability_clause": "", "dispute_resolution": "" }} """ response = chat_with_model(prompt, temperature=0.1) # 低温度确保格式准确 # 解析JSON响应 try: import json # 从响应中提取JSON部分 json_start = response.find('{') json_end = response.rfind('}') + 1 json_str = response[json_start:json_end] return json.loads(json_str) except: # 如果解析失败，返回原始响应 return {"raw_response": response}

5.3 多文档对比分析

比较多个相关文档的异同：

def compare_documents(doc1: str, doc2: str, focus_points: list): """比较两个文档在指定要点上的异同""" focus_str = "\n".join([f"{i+1}. {point}" for i, point in enumerate(focus_points)]) prompt = f"""请比较以下两个文档，重点关注： {focus_str} 文档1： {doc1[:10000]} 文档2： {doc2[:10000]} 请按以下格式回答： 1. 相同点： - 要点1：说明 - 要点2：说明 2. 不同点： - 要点1：文档1的观点 vs 文档2的观点 - 要点2：文档1的观点 vs 文档2的观点 3. 总体评价： - 文档1的特点 - 文档2的特点 - 适用场景建议 """ return chat_with_model(prompt, max_length=800)

6. 高级功能与扩展

GLM-4-9B-Chat-1M还支持一些高级功能，让我们来看看怎么用。

6.1 函数调用（Function Calling）

函数调用让模型可以调用外部工具，大大扩展了能力边界：

def setup_function_calling(): """设置函数调用能力""" # 定义可用的函数 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": "calculate", "description": "执行数学计算", "parameters": { "type": "object", "properties": { "expression": { "type": "string", "description": "数学表达式，如(10+5)*3" } }, "required": ["expression"] } } } ] # 实际的函数实现 def get_weather(city: str, date: str = None): # 这里应该调用天气API return f"{city}的天气是晴天，温度25℃" def calculate(expression: str): try: result = eval(expression) return f"{expression} = {result}" except: return f"无法计算表达式: {expression}" return { "tools": tools, "implementations": { "get_weather": get_weather, "calculate": calculate } } def handle_function_call(messages: list, tools_config: dict): """处理函数调用请求""" # 构建包含工具描述的对话 system_prompt = "你是一个有帮助的助手，可以调用工具来帮助用户。" if tools_config["tools"]: system_prompt += " 你可以使用的工具：" + str(tools_config["tools"]) messages_with_tools = [{"role": "system", "content": system_prompt}] + messages # 调用模型，让它决定是否需要调用函数 response = chat_with_model(messages_with_tools, temperature=0.1) # 解析响应，看是否包含函数调用 # 这里需要根据实际响应格式来解析 # GLM-4-9B-Chat-1M支持特定的函数调用格式 return response

6.2 代码执行能力

模型内置了Python代码执行环境，可以运行代码并返回结果：

def execute_code_with_model(code: str): """通过模型执行代码""" prompt = f"""请执行以下Python代码，并返回结果： ```python {code} ``` 执行结果：""" # 设置系统提示，告诉模型可以执行代码 messages = [ {"role": "system", "content": "你是一个Python代码执行助手，可以运行用户提供的代码并返回结果。"}, {"role": "user", "content": prompt} ] response = chat_with_model(messages, temperature=0.1) # 实际生产环境中，应该在安全沙箱中执行代码 # 这里只是演示模型的能力 return response

7. 监控与维护

服务上线后，监控和维护同样重要。

7.1 添加监控指标

from prometheus_client import Counter, Histogram, generate_latest from fastapi import Response import time # 定义监控指标 REQUEST_COUNT = Counter('http_requests_total', 'Total HTTP requests', ['method', 'endpoint', 'status']) REQUEST_LATENCY = Histogram('http_request_duration_seconds', 'HTTP request latency', ['endpoint']) @app.middleware("http") async def monitor_requests(request, call_next): """监控中间件""" start_time = time.time() endpoint = request.url.path try: response = await call_next(request) # 记录请求 REQUEST_COUNT.labels( method=request.method, endpoint=endpoint, status=response.status_code ).inc() # 记录延迟 REQUEST_LATENCY.labels(endpoint=endpoint).observe(time.time() - start_time) return response except Exception as e: REQUEST_COUNT.labels( method=request.method, endpoint=endpoint, status=500 ).inc() raise @app.get("/metrics") async def metrics(): """Prometheus指标端点""" return Response(generate_latest(), media_type="text/plain")

7.2 日志记录

import logging import json from datetime import datetime # 配置日志 logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('glm_api.log'), logging.StreamHandler() ] ) logger = logging.getLogger(__name__) def log_request(request_id: str, prompt: str, response: str, time_cost: float, tokens_used: int): """记录请求日志""" log_entry = { "timestamp": datetime.now().isoformat(), "request_id": request_id, "prompt_length": len(prompt), "response_length": len(response), "time_cost": time_cost, "tokens_used": tokens_used, "prompt_preview": prompt[:100] + "..." if len(prompt) > 100 else prompt } logger.info(json.dumps(log_entry, ensure_ascii=False))

8. 总结

通过本文的步骤，你应该已经成功部署了GLM-4-9B-Chat-1M，并把它封装成了可用的API服务。我们来回顾一下关键点：

模型的核心优势：

• 100万token的超长上下文，真正能处理长文档
• INT4量化后只需9GB显存，硬件要求亲民
• 内置长文本处理模板，开箱即用
• 支持函数调用和代码执行，扩展性强

部署的关键步骤：

1. 环境准备：确保硬件和软件符合要求
2. 模型加载：使用量化技术减少显存占用
3. API封装：用FastAPI创建RESTful接口
4. 性能优化：使用vLLM提升吞吐量
5. 生产部署：配置Gunicorn和监控

实际应用建议：

• 对于文档总结，可以分段处理再合并
• 使用缓存提升重复请求的响应速度
• 添加监控和日志，便于问题排查
• 根据实际需求调整温度等生成参数

GLM-4-9B-Chat-1M在长文本处理场景下确实有独特优势。无论是法律文档分析、技术报告总结，还是多文档对比，它都能提供不错的支持。而且相比动辄需要数百GB显存的大模型，它的部署成本要低得多。

当然，任何技术方案都有其局限性。GLM-4-9B-Chat-1M在创意写作、复杂推理等方面可能不如更大的模型。但在长文本处理这个特定领域，它确实是个性价比很高的选择。

希望这篇指南能帮助你快速上手GLM-4-9B-Chat-1M。在实际使用过程中，你可能会遇到各种具体问题，这时候最好的办法就是多尝试、多调整。每个应用场景都有其特殊性，需要根据实际情况优化配置。

获取更多AI镜像

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