ChatGLM3-6B-128K与Python集成开发：构建智能对话系统

如果你正在寻找一个既能处理超长对话，又容易上手集成的智能对话模型，那么ChatGLM3-6B-128K绝对值得你关注。这个模型最大的亮点就是支持128K的超长上下文，这意味着它能记住相当于120页A4纸的对话内容，对于需要处理复杂文档、长篇幅对话的应用场景来说，简直是量身定做。

我最近在一个客户项目中就用到了这个模型，他们需要构建一个智能客服系统，能够处理用户上传的几十页产品手册，然后回答各种技术问题。传统的对话模型往往记不住那么多内容，用户问几个问题后，模型就“失忆”了。但用了ChatGLM3-6B-128K之后，这个问题迎刃而解。

今天我就来分享一下，如何用Python把这个强大的模型集成到你的项目中，从基础的API调用到复杂的上下文管理，一步步带你构建一个实用的智能对话系统。

1. 为什么选择ChatGLM3-6B-128K？

在开始技术实现之前，我们先聊聊为什么这个模型特别适合集成开发。

首先，128K的上下文长度是个什么概念？简单来说，它能记住大约9万个汉字的内容。想象一下，你可以把一整本产品手册、一份详细的技术文档，甚至是一篇长篇小说喂给模型，然后它能在整个对话过程中都记得这些内容。这对于文档问答、长对话客服、代码分析等场景来说，简直是神器。

其次，ChatGLM3-6B-128K在ChatGLM3-6B的基础上专门针对长文本进行了优化。不是简单地把训练数据变长，而是从位置编码到训练方法都做了针对性设计。官方建议，如果你的上下文长度基本在8K以内，用普通的ChatGLM3-6B就够了；但如果需要处理超过8K的长文本，那就得用这个128K版本。

从部署角度看，这个模型只有3.6GB大小，对硬件要求相对友好。而且它保留了ChatGLM系列对话流畅、部署门槛低的优点，还支持工具调用、代码执行等高级功能，扩展性很强。

2. 快速上手：基础API调用

我们先从最简单的开始，看看怎么用Python调用这个模型。

2.1 环境准备

首先确保你已经部署好了ChatGLM3-6B-128K模型。如果你用的是Ollama，安装很简单：

ollama run chatglm3:6b

这个命令会自动下载并启动模型。如果你需要128K版本，可能需要从Hugging Face手动下载，不过Ollama的chatglm3:6b标签实际上就是128K版本。

Python环境方面，你需要安装ollama的Python客户端：

pip install ollama

2.2 最简单的对话

先来一个最基础的对话示例，感受一下模型的能力：

import ollama

def simple_chat():
    """最简单的单轮对话"""
    response = ollama.chat(
        model='chatglm3:6b',
        messages=[
            {'role': 'user', 'content': '你好，请介绍一下你自己'}
        ]
    )
    
    print("模型回复：")
    print(response['message']['content'])

if __name__ == '__main__':
    simple_chat()

运行这个脚本，你会看到模型用中文回复你。虽然简单，但这已经是一个完整的AI对话系统了。

2.3 多轮对话实现

真正的对话系统需要支持多轮对话，也就是模型要记住之前的对话历史。用ChatGLM3-6B-128K实现这个功能特别简单：

import ollama

class ChatSession:
    """对话会话管理类"""
    
    def __init__(self, model_name='chatglm3:6b'):
        self.model = model_name
        self.messages = []  # 存储对话历史
        
    def add_message(self, role, content):
        """添加消息到对话历史"""
        self.messages.append({'role': role, 'content': content})
        
    def chat(self, user_input):
        """发送用户输入并获取回复"""
        # 添加用户消息
        self.add_message('user', user_input)
        
        # 调用模型
        response = ollama.chat(
            model=self.model,
            messages=self.messages
        )
        
        # 获取模型回复
        assistant_reply = response['message']['content']
        
        # 添加助手回复到历史
        self.add_message('assistant', assistant_reply)
        
        return assistant_reply
    
    def clear_history(self):
        """清空对话历史"""
        self.messages = []

# 使用示例
def multi_turn_chat_example():
    session = ChatSession()
    
    # 第一轮对话
    reply1 = session.chat("你好，我是张三")
    print(f"模型回复1: {reply1}")
    
    # 第二轮对话 - 模型记得我是张三
    reply2 = session.chat("我刚才说我叫什么名字？")
    print(f"模型回复2: {reply2}")
    
    # 第三轮对话 - 继续上下文
    reply3 = session.chat("你能用我的名字写一首诗吗？")
    print(f"模型回复3: {reply3}")

if __name__ == '__main__':
    multi_turn_chat_example()

这个ChatSession类封装了对话历史管理，每次对话都会把整个历史传给模型，这样模型就能记住之前的所有对话内容。这就是构建智能对话系统的核心基础。

3. 处理长文本：128K上下文的威力

现在我们来体验一下128K上下文的真正威力。假设我们要处理一份很长的技术文档，然后基于文档内容回答问题。

3.1 长文档处理示例

import ollama

def process_long_document():
    """处理长文档并回答问题"""
    
    # 模拟一个很长的文档（这里用重复文本模拟，实际应用中可以是真实的文档）
    long_document = """
    产品技术规格手册
    
    第一章：产品概述
    本产品是一款智能家居控制中心，支持语音控制、手机APP控制和物理按键控制三种操作方式。
    产品尺寸为200mm × 150mm × 50mm，重量约1.2kg。
    采用ARM Cortex-A53四核处理器，主频1.5GHz，内存2GB，存储16GB。
    
    第二章：网络连接
    支持Wi-Fi 6、蓝牙5.2、Zigbee 3.0三种无线连接方式。
    Wi-Fi支持2.4GHz和5GHz双频段，最大传输速率1200Mbps。
    蓝牙支持Mesh组网，最多可连接128个设备。
    
    """ * 50  # 重复50次模拟长文档
    
    # 构建包含长文档的对话
    messages = [
        {
            'role': 'user', 
            'content': f"""请仔细阅读以下产品手册，然后回答我的问题。
            
            产品手册内容：
            {long_document}
            
            问题：本产品支持哪些无线连接方式？最大传输速率是多少？
            """
        }
    ]
    
    # 调用模型
    response = ollama.chat(
        model='chatglm3:6b',
        messages=messages
    )
    
    print("问题：本产品支持哪些无线连接方式？最大传输速率是多少？")
    print("\n模型回答：")
    print(response['message']['content'])

if __name__ == '__main__':
    process_long_document()

这个例子展示了模型如何处理超长文本。即使文档有几十页，模型也能从中提取关键信息并准确回答问题。在实际项目中，你可以把公司文档、产品手册、技术规范等都喂给模型，构建一个强大的知识问答系统。

3.2 流式响应处理

对于长文本生成，流式响应能显著提升用户体验。用户不用等到全部生成完就能看到部分内容：

import ollama
import time

def stream_chat_example():
    """流式对话示例"""
    
    print("开始流式对话（输入'退出'结束）：")
    
    messages = []
    
    while True:
        user_input = input("\n你：")
        if user_input.lower() == '退出':
            break
            
        messages.append({'role': 'user', 'content': user_input})
        
        print("AI：", end='', flush=True)
        
        # 流式调用
        stream = ollama.chat(
            model='chatglm3:6b',
            messages=messages,
            stream=True
        )
        
        full_response = ""
        for chunk in stream:
            content = chunk['message']['content']
            print(content, end='', flush=True)
            full_response += content
            time.sleep(0.02)  # 稍微延迟，让输出更自然
            
        print()  # 换行
        
        # 将完整回复添加到消息历史
        messages.append({'role': 'assistant', 'content': full_response})

if __name__ == '__main__':
    stream_chat_example()

流式响应不仅让用户体验更好，还能在生成过程中实时显示进度，对于生成长文本特别有用。

4. 构建完整的对话系统API

现在我们来构建一个更完整的对话系统，包含API接口和高级功能。

4.1 基于FastAPI的REST API

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional
import ollama
import uuid
from datetime import datetime

app = FastAPI(title="ChatGLM3对话系统API")

# 数据模型
class Message(BaseModel):
    role: str  # 'user' 或 'assistant'
    content: str

class ChatRequest(BaseModel):
    messages: List[Message]
    session_id: Optional[str] = None
    stream: bool = False
    max_tokens: Optional[int] = None
    temperature: float = 0.7

class ChatResponse(BaseModel):
    session_id: str
    message: Message
    created_at: str

# 会话管理
sessions = {}

@app.post("/chat", response_model=ChatResponse)
async def chat_endpoint(request: ChatRequest):
    """对话接口"""
    
    # 处理会话ID
    if not request.session_id:
        session_id = str(uuid.uuid4())
        sessions[session_id] = []
    else:
        session_id = request.session_id
        if session_id not in sessions:
            sessions[session_id] = []
    
    # 准备消息
    session_messages = sessions[session_id]
    
    # 添加新消息到会话历史
    for msg in request.messages:
        session_messages.append({'role': msg.role, 'content': msg.content})
    
    try:
        # 调用模型
        if request.stream:
            # 流式响应需要特殊处理
            raise HTTPException(status_code=501, detail="流式响应暂未实现")
        else:
            response = ollama.chat(
                model='chatglm3:6b',
                messages=session_messages,
                options={
                    'temperature': request.temperature,
                    'num_predict': request.max_tokens if request.max_tokens else 2048
                }
            )
            
            assistant_message = Message(
                role='assistant',
                content=response['message']['content']
            )
            
            # 保存助手回复到会话历史
            sessions[session_id].append({
                'role': 'assistant',
                'content': assistant_message.content
            })
            
            return ChatResponse(
                session_id=session_id,
                message=assistant_message,
                created_at=datetime.now().isoformat()
            )
            
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"模型调用失败: {str(e)}")

@app.get("/sessions/{session_id}")
async def get_session_history(session_id: str):
    """获取会话历史"""
    if session_id not in sessions:
        raise HTTPException(status_code=404, detail="会话不存在")
    
    return {
        "session_id": session_id,
        "messages": sessions[session_id],
        "message_count": len(sessions[session_id])
    }

@app.delete("/sessions/{session_id}")
async def delete_session(session_id: str):
    """删除会话"""
    if session_id in sessions:
        del sessions[session_id]
        return {"message": "会话已删除"}
    else:
        raise HTTPException(status_code=404, detail="会话不存在")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

这个API提供了完整的对话管理功能，包括：

• 创建和管理对话会话
• 支持多轮对话
• 可配置的生成参数（温度、最大token数等）
• 会话历史查询和删除

4.2 上下文窗口管理

虽然ChatGLM3-6B-128K支持很长的上下文，但在实际使用中，我们仍然需要管理上下文窗口，避免无限制增长：

class SmartChatSession:
    """智能对话会话管理，包含上下文窗口管理"""
    
    def __init__(self, model_name='chatglm3:6b', max_history=20, max_tokens=32000):
        self.model = model_name
        self.messages = []
        self.max_history = max_history  # 最大对话轮数
        self.max_tokens = max_tokens    # 最大token数
        self.token_count = 0
        
    def estimate_tokens(self, text):
        """简单估算文本的token数量（实际应该用tokenizer）"""
        # 中文大致按2个字符1个token估算
        return len(text) // 2
    
    def add_message(self, role, content):
        """添加消息，并管理上下文窗口"""
        token_cost = self.estimate_tokens(content)
        
        # 如果添加新消息会超出限制，删除最早的消息
        while (self.token_count + token_cost) > self.max_tokens and len(self.messages) > 1:
            removed = self.messages.pop(0)
            self.token_count -= self.estimate_tokens(removed['content'])
        
        # 添加新消息
        self.messages.append({'role': role, 'content': content})
        self.token_count += token_cost
        
        # 如果对话轮数太多，删除最早的对话（保留系统提示）
        if len(self.messages) > self.max_history * 2 + 1:  # *2因为每轮有user和assistant
            # 保留系统提示（如果有）和最近的消息
            if self.messages[0]['role'] == 'system':
                # 保留系统提示
                system_msg = self.messages.pop(0)
                # 删除最早的一对对话
                if len(self.messages) >= 2:
                    self.messages.pop(0)  # user
                    self.messages.pop(0)  # assistant
                # 重新添加系统提示
                self.messages.insert(0, system_msg)
            else:
                # 删除最早的一对对话
                if len(self.messages) >= 2:
                    self.messages.pop(0)  # user
                    self.messages.pop(0)  # assistant
    
    def chat(self, user_input, system_prompt=None):
        """智能对话"""
        # 如果有系统提示且是第一次对话，添加系统提示
        if system_prompt and not self.messages:
            self.add_message('system', system_prompt)
        
        # 添加用户输入
        self.add_message('user', user_input)
        
        # 调用模型
        response = ollama.chat(
            model=self.model,
            messages=self.messages
        )
        
        # 获取回复
        reply = response['message']['content']
        
        # 添加助手回复
        self.add_message('assistant', reply)
        
        # 返回当前token使用情况
        stats = {
            'reply': reply,
            'message_count': len(self.messages),
            'estimated_tokens': self.token_count,
            'max_tokens': self.max_tokens
        }
        
        return stats

# 使用示例
def smart_chat_example():
    """智能对话示例"""
    
    system_prompt = """你是一个专业的客服助手，负责回答产品相关问题。
    请保持友好、专业的语气，如果不知道答案，请如实告知。"""
    
    session = SmartChatSession(
        max_history=10,      # 最多记住10轮对话
        max_tokens=16000     # 最多使用16000个token
    )
    
    # 模拟长对话
    questions = [
        "你们的产品支持Wi-Fi吗？",
        "具体支持哪个版本的Wi-Fi？",
        "最大传输速率是多少？",
        "蓝牙支持Mesh组网吗？",
        "最多可以连接多少个设备？",
        "产品的处理器是什么型号？",
        "内存有多大？",
        "存储空间是多少？",
        "支持语音控制吗？",
        "有手机APP吗？",
        "物理按键在哪里？",  # 第11个问题，会触发上下文清理
    ]
    
    for i, question in enumerate(questions, 1):
        print(f"\n[{i}] 用户: {question}")
        result = session.chat(question, system_prompt)
        print(f"AI: {result['reply'][:100]}...")  # 只显示前100字符
        print(f"状态: {result['message_count']}条消息，约{result['estimated_tokens']} tokens")

if __name__ == '__main__':
    smart_chat_example()

这个智能会话管理器会自动维护上下文窗口，确保不会超出模型的限制，同时尽量保留重要的对话历史。

5. 实际应用场景示例

5.1 技术文档问答系统

import ollama
import json

class DocumentQASystem:
    """文档问答系统"""
    
    def __init__(self):
        self.model = 'chatglm3:6b'
        self.documents = {}  # 文档库：{doc_id: content}
        
    def add_document(self, doc_id, content):
        """添加文档到知识库"""
        self.documents[doc_id] = content
        
    def query(self, question, doc_ids=None, max_context=80000):
        """查询文档"""
        # 选择要查询的文档
        if doc_ids is None:
            doc_ids = list(self.documents.keys())
        
        # 构建上下文
        context_parts = []
        total_length = 0
        
        for doc_id in doc_ids:
            if doc_id in self.documents:
                content = self.documents[doc_id]
                if total_length + len(content) < max_context:
                    context_parts.append(f"文档[{doc_id}]:\n{content}")
                    total_length += len(content)
                else:
                    break
        
        context = "\n\n".join(context_parts)
        
        # 构建提示词
        prompt = f"""基于以下文档内容，回答用户的问题。如果文档中没有相关信息，请如实告知。

文档内容：
{context}

用户问题：{question}

请根据文档内容提供准确的回答。"""
        
        # 调用模型
        response = ollama.chat(
            model=self.model,
            messages=[{'role': 'user', 'content': prompt}]
        )
        
        return response['message']['content']
    
    def batch_query(self, questions, doc_ids=None):
        """批量查询"""
        results = {}
        for question in questions:
            results[question] = self.query(question, doc_ids)
        return results

# 使用示例
def document_qa_example():
    """文档问答示例"""
    
    qa_system = DocumentQASystem()
    
    # 添加文档（实际项目中可以从文件读取）
    qa_system.add_document(
        "product_spec",
        """产品名称：智能家居控制中心
型号：HCC-2024
处理器：ARM Cortex-A53 四核 1.5GHz
内存：2GB LPDDR4
存储：16GB eMMC
无线连接：Wi-Fi 6 (802.11ax), 蓝牙5.2, Zigbee 3.0
有线接口：千兆以太网×1, USB 3.0×2, HDMI×1
电源：DC 12V/2A
尺寸：200×150×50mm
重量：1.2kg
工作温度：0-40°C
支持协议：MQTT, HTTP, CoAP"""
    )
    
    qa_system.add_document(
        "user_manual",
        """使用说明：
1. 首次使用请连接电源
2. 下载手机APP并注册账号
3. 通过APP添加设备
4. 按照提示完成Wi-Fi配置
5. 开始添加智能设备

注意事项：
- 请勿放置在潮湿环境中
- 避免阳光直射
- 定期清理通风口
- 固件更新时请勿断电

故障排除：
1. 无法连接Wi-Fi：检查密码，重启路由器
2. 设备离线：检查网络连接
3. APP无法控制：重启控制中心"""
    )
    
    # 查询测试
    questions = [
        "这个产品的处理器是什么？",
        "支持哪些无线连接方式？",
        "首次使用需要哪些步骤？",
        "设备离线了怎么办？",
        "产品的尺寸和重量是多少？"
    ]
    
    print("文档问答系统测试：")
    print("=" * 50)
    
    for question in questions:
        answer = qa_system.query(question)
        print(f"\nQ: {question}")
        print(f"A: {answer}")
        print("-" * 50)

if __name__ == '__main__':
    document_qa_example()

5.2 代码分析与解释

class CodeAnalyzer:
    """代码分析助手"""
    
    def __init__(self):
        self.model = 'chatglm3:6b'
        
    def analyze_code(self, code, language='python'):
        """分析代码"""
        prompt = f"""请分析以下{language}代码：

```{language}
{code}

请提供：

1. 代码功能说明

2. 可能的问题或改进建议

3. 时间复杂度分析（如果适用）

4. 安全性考虑（如果适用）"""

    response = ollama.chat(
        model=self.model,
        messages=[{'role': 'user', 'content': prompt}]
    )
    
    return response['message']['content']
   

   def explain_error(self, error_message, code_snippet): """解释错误信息""" prompt = f"""遇到以下错误：

错误信息： {error_message}

相关代码：

{code_snippet}

请解释：

1. 这个错误是什么意思？

2. 可能的原因是什么？

3. 如何修复这个错误？"""

    response = ollama.chat(
        model=self.model,
        messages=[{'role': 'user', 'content': prompt}]
    )
    
    return response['message']['content']
   

使用示例

def code_analysis_example(): """代码分析示例"""

analyzer = CodeAnalyzer()

# 示例代码
sample_code = """

def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right)

测试

numbers = [3, 6, 8, 10, 1, 2, 1] sorted_numbers = quick_sort(numbers) print(sorted_numbers) """

print("代码分析示例：")
print("=" * 50)
print("分析快速排序代码：")
analysis = analyzer.analyze_code(sample_code, 'python')
print(analysis)

print("\n" + "=" * 50)
print("错误解释示例：")

error_msg = "IndexError: list index out of range"
error_code = """

def get_element(lst, index): return lst[index]

result = get_element([1, 2, 3], 5) """

explanation = analyzer.explain_error(error_msg, error_code)
print(explanation)

if name == 'main': code_analysis_example()

## 6. 性能优化与最佳实践

### 6.1 批量处理优化

```python
import ollama
import asyncio
from concurrent.futures import ThreadPoolExecutor
import time

class BatchProcessor:
    """批量处理器"""
    
    def __init__(self, model='chatglm3:6b', max_workers=4):
        self.model = model
        self.executor = ThreadPoolExecutor(max_workers=max_workers)
        
    def process_single(self, prompt):
        """处理单个提示"""
        try:
            response = ollama.chat(
                model=self.model,
                messages=[{'role': 'user', 'content': prompt}]
            )
            return response['message']['content']
        except Exception as e:
            return f"处理失败: {str(e)}"
    
    def process_batch(self, prompts):
        """批量处理多个提示"""
        with ThreadPoolExecutor(max_workers=min(len(prompts), 4)) as executor:
            futures = [executor.submit(self.process_single, prompt) for prompt in prompts]
            results = [future.result() for future in futures]
        return results
    
    async def process_batch_async(self, prompts):
        """异步批量处理"""
        loop = asyncio.get_event_loop()
        tasks = []
        
        for prompt in prompts:
            task = loop.run_in_executor(self.executor, self.process_single, prompt)
            tasks.append(task)
        
        results = await asyncio.gather(*tasks)
        return results

# 性能测试
def performance_test():
    """性能测试"""
    
    processor = BatchProcessor()
    
    # 测试数据
    test_prompts = [
        "用一句话介绍人工智能",
        "Python是什么？",
        "机器学习的基本概念",
        "深度学习与机器学习的区别",
        "什么是神经网络？",
        "解释一下梯度下降",
        "监督学习是什么？",
        "无监督学习的例子",
    ] * 3  # 重复3次，共24个提示
    
    print(f"测试批量处理 {len(test_prompts)} 个提示...")
    
    # 顺序处理
    print("\n1. 顺序处理测试：")
    start_time = time.time()
    sequential_results = []
    for prompt in test_prompts[:8]:  # 只测试前8个
        result = processor.process_single(prompt)
        sequential_results.append(result)
    seq_time = time.time() - start_time
    print(f"   处理8个提示用时: {seq_time:.2f}秒")
    
    # 批量处理
    print("\n2. 批量处理测试：")
    start_time = time.time()
    batch_results = processor.process_batch(test_prompts[:8])
    batch_time = time.time() - start_time
    print(f"   处理8个提示用时: {batch_time:.2f}秒")
    print(f"   加速比: {seq_time/batch_time:.2f}x")
    
    # 异步处理
    print("\n3. 异步处理测试：")
    async def test_async():
        start_time = time.time()
        async_results = await processor.process_batch_async(test_prompts[:8])
        async_time = time.time() - start_time
        print(f"   处理8个提示用时: {async_time:.2f}秒")
        return async_time
    
    async_time = asyncio.run(test_async())
    
    print("\n总结：")
    print(f"   顺序处理: {seq_time:.2f}秒")
    print(f"   批量处理: {batch_time:.2f}秒")
    print(f"   异步处理: {async_time:.2f}秒")

if __name__ == '__main__':
    performance_test()

6.2 缓存优化

import hashlib
import json
from functools import lru_cache
import ollama

class CachedChatGLM:
    """带缓存的ChatGLM客户端"""
    
    def __init__(self, model='chatglm3:6b', cache_size=1000):
        self.model = model
        self.cache_size = cache_size
        
    def _get_cache_key(self, messages, temperature=0.7, max_tokens=2048):
        """生成缓存键"""
        cache_data = {
            'messages': messages,
            'temperature': temperature,
            'max_tokens': max_tokens,
            'model': self.model
        }
        cache_str = json.dumps(cache_data, sort_keys=True)
        return hashlib.md5(cache_str.encode()).hexdigest()
    
    @lru_cache(maxsize=1000)
    def _cached_chat(self, cache_key, messages_json, temperature, max_tokens):
        """带缓存的聊天方法"""
        messages = json.loads(messages_json)
        
        response = ollama.chat(
            model=self.model,
            messages=messages,
            options={
                'temperature': temperature,
                'num_predict': max_tokens
            }
        )
        
        return response['message']['content']
    
    def chat(self, messages, temperature=0.7, max_tokens=2048):
        """聊天接口，带缓存"""
        cache_key = self._get_cache_key(messages, temperature, max_tokens)
        messages_json = json.dumps(messages, sort_keys=True)
        
        return self._cached_chat(cache_key, messages_json, temperature, max_tokens)

# 使用示例
def cache_test():
    """缓存测试"""
    
    cached_client = CachedChatGLM()
    
    # 相同的问题
    messages = [{'role': 'user', 'content': '什么是机器学习？'}]
    
    print("第一次调用（会调用模型）：")
    start_time = time.time()
    result1 = cached_client.chat(messages)
    time1 = time.time() - start_time
    print(f"   结果: {result1[:50]}...")
    print(f"   用时: {time1:.3f}秒")
    
    print("\n第二次调用相同问题（从缓存读取）：")
    start_time = time.time()
    result2 = cached_client.chat(messages)
    time2 = time.time() - start_time
    print(f"   结果: {result2[:50]}...")
    print(f"   用时: {time2:.3f}秒")
    
    print(f"\n缓存加速: {time1/time2:.1f}倍")
    
    # 不同温度参数
    print("\n不同温度参数的调用：")
    start_time = time.time()
    result3 = cached_client.chat(messages, temperature=0.9)
    time3 = time.time() - start_time
    print(f"   温度0.9用时: {time3:.3f}秒")
    
    # 相同温度再次调用
    start_time = time.time()
    result4 = cached_client.chat(messages, temperature=0.9)
    time4 = time.time() - start_time
    print(f"   温度0.9缓存用时: {time4:.3f}秒")

if __name__ == '__main__':
    import time
    cache_test()

7. 总结

通过上面的示例，你应该已经掌握了如何将ChatGLM3-6B-128K集成到Python项目中。这个模型的128K长上下文能力确实很实用，特别是在处理文档问答、长对话等场景时，优势明显。

实际使用中，有几点经验分享：首先，虽然模型支持超长上下文，但合理管理上下文窗口还是很重要的，否则响应时间会变长。其次，对于生产环境，建议加上缓存和批量处理优化，能显著提升性能。最后，根据具体场景设计合适的提示词，能让模型发挥更好的效果。

集成过程比想象中要简单，Ollama的Python客户端用起来很顺手，API设计也很直观。如果你需要处理中文长文本任务，ChatGLM3-6B-128K是个不错的选择，既有足够的能力，又不会对硬件要求太高。

当然，每个项目需求不同，你可能需要根据自己的情况调整代码。比如有的项目需要更严格的错误处理，有的需要支持更多模型参数，有的可能需要集成到现有的Web框架中。但核心思路都是一样的：管理好对话历史，利用好128K的上下文，设计好提示词。

希望这些示例代码能帮你快速上手。在实际项目中，你可能还会遇到各种具体问题，比如并发处理、错误重试、监控日志等，这些都可以在现有基础上逐步完善。最重要的是先跑起来，看到效果，然后再慢慢优化。

---

获取更多AI镜像

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