这次我们来看一个刚开源的端侧智能体模型：Liquid AI 发布的 LFM2.5-2.6B。这个项目的重点不是参数规模有多大，而是它能否在你的本地设备上流畅运行，并真正调用外部工具完成任务。对于关心本地部署、显存占用、工具调用和开放权重的开发者来说，这篇文章可以直接收藏。

LFM2.5-2.6B 是一个参数规模为 26 亿的轻量级语言模型，由 Liquid AI 开源。它的核心定位是“端侧智能体”，这意味着它被设计为在个人电脑、边缘设备甚至移动端上运行，而不是依赖云端 API。模型最大的亮点是原生支持工具调用（Tool Calling），你可以让它执行诸如调用命令行、查询天气、控制智能家居等具体操作。同时，模型权重完全开放，允许商业使用，这为本地私有化部署和二次开发扫清了障碍。

本文将带你快速了解这个模型的核心能力、硬件门槛，并完成从环境准备、模型下载到基础对话和工具调用测试的全流程。如果你手头有 8GB 以上显存的 GPU，或者愿意用 CPU 进行推理测试，那么跟着步骤走，半小时内就能看到实际效果。

1. 核心能力速览

在深入部署之前，我们先通过一个表格快速把握 LFM2.5-2.6B 的关键信息。所有信息均基于其开源仓库的官方描述和常见实践。

从表格可以看出，这是一个门槛相对亲民的模型。8GB显存是当前中端游戏显卡（如RTX 4060 Ti）的起步配置，意味着大部分开发者都有条件进行本地测试。其“工具调用”特性是区别于普通聊天模型的关键，也是本文测试的重点。

2. 适用场景与使用边界

在部署之前，明确它能做什么、不能做什么，以及需要注意什么，可以避免走弯路。

它适合谁？

1. AI应用开发者：希望将智能体能力集成到本地应用中，避免云端API的延迟、成本和隐私风险。
2. 边缘计算研究者：需要在资源受限的设备上研究AI模型的部署与推理。
3. 技术爱好者：对“智能体如何调用工具”的实现原理感兴趣，想亲手实践。
4. 企业IT部门：寻求可私有化部署、支持内部工具调用的AI解决方案。

它能解决什么问题？

• 本地自动化：根据自然语言指令，自动执行一系列预定义的工具操作（如文件处理、数据查询）。
• 私有知识库问答增强：结合检索增强生成（RAG），并调用工具获取实时信息。
• 边缘设备交互：作为智能中枢，理解用户指令后调用设备接口（如摄像头、传感器）。

它不适合什么场景？

• 需要极高知识广度或复杂推理的任务：2.6B参数模型在专业领域知识、复杂逻辑链条上能力有限。
• 对响应速度有极致要求（毫秒级）：端侧推理速度受硬件限制，可能无法与优化后的云端大模型相比。
• 完全无编程基础的纯用户：部署、配置工具调用环境需要一定的技术能力。

重要使用边界与合规提醒

1. 工具安全：模型调用工具的能力是一把双刃剑。务必严格控制模型可调用的工具范围，避免其执行危险命令（如rm -rf /、格式化磁盘）。
2. 权限隔离：运行模型的进程应使用最小必要权限，避免越权操作。
3. 内容合规：作为基座模型，其输出需符合法律法规。在涉及内容生成的应用中，应添加必要的过滤和审核机制。
4. 授权与隐私：如果工具调用涉及访问用户数据或第三方API，必须确保已获得合法授权，并妥善处理隐私信息。

3. 环境准备与前置条件

为了让 LFM2.5-2.6B 跑起来，你需要准备好以下环境。这是一个通用清单，具体版本请以模型仓库的requirements.txt为准。

操作系统

• 推荐: Ubuntu 20.04/22.04 LTS 或 Windows 10/11 with WSL2。
• 可选: macOS (Apple Silicon 芯片性能更佳)。

Python 环境

• Python 版本: 3.8, 3.9 或 3.10。建议使用conda或venv创建独立的虚拟环境。
• 包管理工具:pip最新版。

深度学习框架

• PyTorch: >= 2.0.0。务必安装与你的 CUDA 版本匹配的 PyTorch。
• CUDA/cuDNN(GPU用户): 如果使用 NVIDIA GPU，请确保驱动和 CUDA 工具包已正确安装。CUDA 11.8 或 12.x 是常见选择。
• 替代方案(CPU用户): 可以安装纯 CPU 版本的 PyTorch，推理速度会慢很多，但可以运行。

模型与工具库

• Hugging Facetransformers: 核心库，用于加载模型和分词器。
• accelerate: 可选，用于简化混合精度训练和推理。
• bitsandbytes: 可选，用于 8-bit 或 4-bit 量化，以进一步降低显存占用。
• 工具调用依赖: 取决于你希望模型调用什么工具。例如，调用命令行需要subprocess库，调用 Web API 需要requests库。

硬件资源检查

• GPU 用户: 运行nvidia-smi检查显卡型号和显存大小。确保至少有 8GB 空闲显存以获得较好体验。
• CPU 用户: 确保系统有足够的内存（RAM），建议 16GB 以上。推理速度会显著慢于 GPU。
• 磁盘空间: 下载模型权重和分词器文件需要约 5-10 GB 空间。

4. 安装部署与启动方式

LFM2.5-2.6B 通常通过 Hugging Face Hub 获取。部署的核心步骤是：创建环境 -> 安装依赖 -> 下载模型 -> 编写推理脚本。

步骤 1：创建并激活虚拟环境强烈建议使用虚拟环境隔离依赖。

# 使用 conda (推荐) conda create -n lfm2.5 python=3.10 conda activate lfm2.5 # 或使用 venv python -m venv venv_lfm2.5 # Linux/macOS source venv_lfm2.5/bin/activate # Windows venv_lfm2.5\Scripts\activate

步骤 2：安装核心依赖安装 PyTorch 和 Hugging Face 库。请根据你的 CUDA 版本前往 PyTorch 官网 获取准确的安装命令。

# 示例：安装 PyTorch with CUDA 11.8 pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 安装 transformers 和 accelerate pip install transformers accelerate # 可选：安装 bitsandbytes 以支持量化（Linux 更易安装） # pip install bitsandbytes

步骤 3：下载模型权重模型应该已经在 Hugging Face Hub 上发布。你可以使用git lfs克隆，或在代码中通过from_pretrained自动下载。

# 方法一：使用 git lfs 克隆（需先安装 git lfs） git lfs install git clone https://huggingface.co/liquid-ai/LFM2.5-2.6B # 方法二：在 Python 代码中指定模型ID，首次运行时会自动下载 # model_name = "liquid-ai/LFM2.5-2.6B"

步骤 4：编写基础推理脚本创建一个demo.py文件，进行最基础的文本生成测试。

import torch from transformers import AutoTokenizer, AutoModelForCausalLM # 指定模型路径（如果是克隆下来的）或模型ID model_name_or_path = "./LFM2.5-2.6B" # 本地路径 # model_name_or_path = "liquid-ai/LFM2.5-2.6B" # Hugging Face ID print("正在加载模型和分词器...") tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( model_name_or_path, torch_dtype=torch.float16, # 使用半精度减少显存占用 device_map="auto", # 自动分配模型层到 GPU/CPU trust_remote_code=True ) print("模型加载完毕。") # 准备输入 prompt = "请用中文介绍一下你自己。" inputs = tokenizer(prompt, return_tensors="pt").to(model.device) # 生成配置 generation_config = { "max_new_tokens": 256, "temperature": 0.7, "do_sample": True, } print(f"输入: {prompt}") print("生成中...") # 生成文本 with torch.no_grad(): outputs = model.generate(**inputs, **generation_config) response = tokenizer.decode(outputs[0], skip_special_tokens=True) print(f"输出: {response}")

步骤 5：运行脚本在激活的虚拟环境中运行你的脚本。

python demo.py

如果一切顺利，你将看到模型加载日志，并最终输出一段自我介绍。第一次运行会因为下载分词器和模型文件而较慢。

5. 功能测试与效果验证

基础对话只是开始，工具调用才是 LFM2.5-2.6B 的灵魂。我们将设计两个层级的测试：基础对话能力测试和工具调用能力测试。

5.1 基础对话能力测试

测试目的：验证模型的基本语言理解和生成能力。操作步骤：修改上面demo.py中的prompt变量，运行脚本。输入示例与预期：

常见失败原因：

1. 输出重复或无意义：可能是temperature参数过低或生成长度不足，尝试调高temperature(如0.9) 或增加max_new_tokens。
2. 生成内容与 prompt 无关：检查模型是否加载正确，或尝试更明确的指令（如“请回答：”）。
3. 显存不足（OOM）：减少max_new_tokens，或尝试启用model.generate(..., use_cache=True)，或使用量化。

5.2 工具调用能力测试（核心）

这是关键部分。我们需要模拟一个工具调用场景。假设我们给模型提供一个“计算器”工具和一个“获取当前时间”的工具。

第一步：定义工具我们在代码中模拟几个简单的工具函数。

# tool_functions.py import json import subprocess from datetime import datetime def calculator(expression: str) -> str: """计算一个数学表达式的结果。""" try: # 警告：直接使用 eval 有安全风险，此处仅作演示。生产环境必须使用安全评估方法。 result = eval(expression) return f"计算结果: {result}" except Exception as e: return f"计算错误: {e}" def get_current_time() -> str: """获取当前系统时间。""" now = datetime.now() return f"当前时间是: {now.strftime('%Y-%m-%d %H:%M:%S')}" def run_shell_command(cmd: str) -> str: """运行一个简单的 shell 命令（仅限安全命令）。""" safe_commands = ['ls', 'pwd', 'date', 'echo'] if cmd.split()[0] not in safe_commands: return "错误：该命令未被允许执行。" try: result = subprocess.run(cmd, shell=True, capture_output=True, text=True, timeout=5) return f"命令输出:\n{result.stdout}\n错误信息:\n{result.stderr}" except subprocess.TimeoutExpired: return "错误：命令执行超时。" except Exception as e: return f"执行出错: {e}" # 工具描述，用于提供给模型 TOOLS = [ { "name": "calculator", "description": "计算一个数学表达式，例如 '2 + 3 * 4'。", "parameters": { "type": "object", "properties": { "expression": {"type": "string", "description": "数学表达式"} }, "required": ["expression"] } }, { "name": "get_current_time", "description": "获取当前的日期和时间。", "parameters": { "type": "object", "properties": {}, "required": [] } }, { "name": "run_shell_command", "description": "运行一个简单的、安全的 shell 命令，如 'ls', 'pwd'。", "parameters": { "type": "object", "properties": { "cmd": {"type": "string", "description": "要执行的 shell 命令"} }, "required": ["cmd"] } } ]

第二步：构建智能体交互循环创建一个agent_demo.py脚本，实现简单的“思考-调用工具-返回结果”的循环。

# agent_demo.py import torch import json from transformers import AutoTokenizer, AutoModelForCausalLM from tool_functions import TOOLS, calculator, get_current_time, run_shell_command model_name_or_path = "./LFM2.5-2.6B" tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( model_name_or_path, torch_dtype=torch.float16, device_map="auto", trust_remote_code=True ) # 将工具描述转换为模型能理解的格式（例如，作为系统提示词的一部分） tools_prompt = "你可以使用以下工具：\n" for tool in TOOLS: tools_prompt += f"- {tool['name']}: {tool['description']}\n" tools_prompt += "\n当你需要调用工具时，请严格按照以下JSON格式回复：\n" tools_prompt += '```json\n{"action": "tool_call", "tool_name": "工具名", "parameters": {"参数名": "参数值"}}\n```\n' tools_prompt += "我会执行工具并返回结果。其他情况请正常对话。\n" def chat_with_agent(user_input, conversation_history=[]): """与智能体进行一轮对话。""" # 构建包含工具描述和历史对话的完整提示 full_prompt = tools_prompt for role, text in conversation_history[-5:]: # 保留最近5轮历史 full_prompt += f"{role}: {text}\n" full_prompt += f"用户: {user_input}\n助手: " inputs = tokenizer(full_prompt, return_tensors="pt").to(model.device) generation_config = { "max_new_tokens": 512, "temperature": 0.7, "do_sample": True, "eos_token_id": tokenizer.eos_token_id, } with torch.no_grad(): outputs = model.generate(**inputs, **generation_config) response = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True) # 尝试解析响应是否为工具调用 tool_result = None if '```json' in response and 'tool_call' in response: try: json_start = response.find('{') json_end = response.rfind('}') + 1 json_str = response[json_start:json_end] action_data = json.loads(json_str) if action_data.get('action') == 'tool_call': tool_name = action_data['tool_name'] params = action_data.get('parameters', {}) # 根据工具名调用实际函数 if tool_name == 'calculator': tool_result = calculator(params.get('expression', '')) elif tool_name == 'get_current_time': tool_result = get_current_time() elif tool_name == 'run_shell_command': tool_result = run_shell_command(params.get('cmd', '')) else: tool_result = f"未知工具: {tool_name}" except json.JSONDecodeError: tool_result = "工具调用格式解析失败。" return response, tool_result # 开始简单的对话测试 if __name__ == "__main__": history = [] print("智能体已启动。输入‘退出’结束。") while True: user_input = input("\n你: ") if user_input.lower() in ['退出', 'exit', 'quit']: break model_response, tool_result = chat_with_agent(user_input, history) print(f"助手原始回复: {model_response}") if tool_result: print(f"[工具执行结果]: {tool_result}") # 将工具结果作为下一轮对话的上下文 history.append(('助手', model_response)) history.append(('系统', f"工具执行结果: {tool_result}")) else: history.append(('助手', model_response))

第三步：运行与验证运行这个脚本，并尝试以下指令：

python agent_demo.py

测试用例：

如果测试通过，说明 LFM2.5-2.6B 具备了基础的“理解指令-选择工具-格式化请求”的智能体能力。这是构建更复杂自动化流程的基石。

6. 接口 API 与批量任务

虽然官方可能不直接提供开箱即用的 API 服务，但我们可以基于 Flask 或 FastAPI 快速封装一个，并设计简单的批量任务处理。

6.1 封装简易 REST API 服务

创建一个app.py文件，使用 Flask 提供生成和工具调用接口。

# app.py from flask import Flask, request, jsonify import torch from transformers import AutoTokenizer, AutoModelForCausalLM from tool_functions import TOOLS, calculator, get_current_time, run_shell_command import json import threading app = Flask(__name__) # 全局加载模型（简单示例，生产环境需优化） print("加载模型中...") model_name_or_path = "./LFM2.5-2.6B" tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( model_name_or_path, torch_dtype=torch.float16, device_map="auto", trust_remote_code=True ) print("模型加载完成。") def generate_response(prompt, max_tokens=256): """基础的文本生成函数。""" inputs = tokenizer(prompt, return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model.generate(**inputs, max_new_tokens=max_tokens, do_sample=True, temperature=0.7) return tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True) @app.route('/generate', methods=['POST']) def generate(): """文本生成接口。""" data = request.json prompt = data.get('prompt', '') max_tokens = data.get('max_tokens', 256) if not prompt: return jsonify({'error': 'Missing prompt'}), 400 try: response = generate_response(prompt, max_tokens) return jsonify({'response': response}) except Exception as e: return jsonify({'error': str(e)}), 500 @app.route('/tool_call', methods=['POST']) def tool_call(): """工具调用接口（简化版，实际需更复杂的Agent逻辑）。""" data = request.json tool_name = data.get('tool_name') parameters = data.get('parameters', {}) # 这里简化了工具路由，实际应有一个工具注册和发现机制 if tool_name == 'calculator': result = calculator(parameters.get('expression', '')) elif tool_name == 'get_current_time': result = get_current_time() elif tool_name == 'run_shell_command': result = run_shell_command(parameters.get('cmd', '')) else: result = f"Tool {tool_name} not found." return jsonify({'result': result}) if __name__ == '__main__': # 启动服务，默认端口 5000 app.run(host='0.0.0.0', port=5000, debug=False, threaded=True)

启动服务：

python app.py

服务启动后，你可以使用curl或 Pythonrequests库进行测试。

# 测试生成接口 curl -X POST http://127.0.0.1:5000/generate \ -H "Content-Type: application/json" \ -d '{"prompt": "你好，请介绍一下你自己。", "max_tokens": 100}' # 测试工具调用接口 curl -X POST http://127.0.0.1:5000/tool_call \ -H "Content-Type: application/json" \ -d '{"tool_name": "get_current_time", "parameters": {}}'

6.2 设计批量任务处理

对于需要处理大量提示词或文档的场景，可以设计一个简单的任务队列。

# batch_processor.py import json import threading import queue from app import generate_response # 假设使用上面的生成函数 class BatchProcessor: def __init__(self, worker_num=2): self.task_queue = queue.Queue() self.results = [] self.worker_num = worker_num self.lock = threading.Lock() def add_task(self, prompt, task_id): self.task_queue.put({'prompt': prompt, 'id': task_id}) def worker(self): while True: try: task = self.task_queue.get(timeout=3) # 3秒超时 if task is None: break response = generate_response(task['prompt']) with self.lock: self.results.append({'id': task['id'], 'prompt': task['prompt'], 'response': response}) self.task_queue.task_done() except queue.Empty: break except Exception as e: with self.lock: self.results.append({'id': task['id'], 'error': str(e)}) self.task_queue.task_done() def run(self, prompts): """ prompts: list of dict, e.g., [{'id':1, 'text':'prompt1'}, ...] """ for item in prompts: self.add_task(item['text'], item['id']) threads = [] for _ in range(self.worker_num): t = threading.Thread(target=self.worker) t.start() threads.append(t) self.task_queue.join() # 等待所有任务完成 # 停止工作线程 for _ in range(self.worker_num): self.task_queue.put(None) for t in threads: t.join() return self.results if __name__ == '__main__': # 示例：批量处理提示词 test_prompts = [ {'id': 1, 'text': '什么是人工智能？'}, {'id': 2, 'text': '讲一个笑话。'}, {'id': 3, 'text': 'Python 的优点是什么？'}, ] processor = BatchProcessor(worker_num=2) results = processor.run(test_prompts) for res in results: print(f"Task {res['id']}: {res.get('response', res.get('error'))}")

这个批量处理器使用了多线程，可以并发处理多个生成请求，提高吞吐量。在实际应用中，你需要根据 GPU 显存大小调整worker_num，避免并发过多导致显存溢出（OOM）。

7. 资源占用与性能观察

本地部署模型，资源占用是必须关注的。以下是观察和优化性能的要点。

如何观察资源占用？

• GPU 显存：在 Linux 终端，使用watch -n 1 nvidia-smi可以每秒刷新一次 GPU 状态。在 Python 代码中，可以使用torch.cuda.memory_allocated()和torch.cuda.max_memory_allocated()。
• CPU 和内存：使用htop(Linux)、Task Manager(Windows) 或Activity Monitor(macOS) 查看。

影响性能的关键因素

1. 上下文长度 (Context Length)：模型能处理的最大文本长度。处理更长的文本（如长文档）会显著增加显存占用和计算时间。请查阅模型卡 (Model Card) 获取该信息。
2. 生成长度 (Max New Tokens)：要求模型生成的内容越长，耗时越长。
3. 批量大小 (Batch Size)：一次性处理多个输入可以提升吞吐量，但会线性增加显存占用。对于 2.6B 模型，在 8GB 显存上，batch_size=1是安全的起点。
4. 精度 (Precision)：使用torch.float16(半精度) 相比torch.float32(单精度) 可以减半显存占用，通常对质量影响很小，是推荐的配置。
5. 量化 (Quantization)：使用bitsandbytes库进行 8-bit 或 4-bit 量化，可以大幅降低显存需求（可能降至 3-4GB），但可能会轻微影响输出质量。

一个简单的性能测试脚本

import torch import time from transformers import AutoTokenizer, AutoModelForCausalLM model_name_or_path = "./LFM2.5-2.6B" tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( model_name_or_path, torch_dtype=torch.float16, device_map="auto", trust_remote_code=True ) prompt = "请用中文回答：机器学习是什么？" inputs = tokenizer(prompt, return_tensors="pt").to(model.device) # 预热 _ = model.generate(**inputs, max_new_tokens=10) # 正式测试 start_time = time.time() with torch.no_grad(): outputs = model.generate(**inputs, max_new_tokens=100, do_sample=False) end_time = time.time() generated_text = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True) token_count = outputs.shape[1] - inputs['input_ids'].shape[1] print(f"生成耗时: {end_time - start_time:.2f} 秒") print(f"生成token数: {token_count}") print(f"平均速度: {token_count / (end_time - start_time):.2f} tokens/秒") print(f"当前GPU显存占用: {torch.cuda.memory_allocated() / 1024**3:.2f} GB") print(f"生成内容: {generated_text[:200]}...")

运行此脚本，你可以得到在当前硬件上模型推理的大致速度。这对于评估是否满足应用场景的实时性要求至关重要。

8. 常见问题与排查方法

在部署和运行过程中，你可能会遇到以下问题。

9. 最佳实践与使用建议

为了让 LFM2.5-2.6B 在你的项目中稳定运行，遵循以下建议：

1. 从小开始，逐步验证：第一次部署时，先用极短的 prompt 和最小的生成长度测试，确保基础流程跑通，再逐步增加复杂度。
2. 固化成功配置：将能稳定运行的模型加载参数（如torch_dtype,device_map）、生成参数（如temperature,max_new_tokens）保存为配置文件，避免每次手动调整。
3. 实现健壮的工具调用：
   • 沙箱环境：对于执行命令、访问文件等危险工具，必须在严格的沙箱或权限隔离环境中运行。
   • 输入验证：对模型传来的工具参数进行严格的类型和范围检查，防止注入攻击。
   • 超时与重试：为工具调用设置超时机制，并考虑失败后的重试或降级策略。
4. 管理模型与数据：
   • 目录分离：将模型文件、输入数据、输出结果、日志文件分别存放在不同的目录中，便于管理。
   • 版本控制：记录使用的模型版本和代码版本，便于问题回溯。
5. 监控与日志：
   • 记录每一次 API 调用的请求、响应时间、token 消耗和可能的错误。
   • 监控 GPU 显存、CPU 和内存的使用情况，设置告警阈值。
6. 安全与合规重中之重：
   • 网络隔离：如果将模型封装为 API 并对公网开放，务必使用防火墙、反向代理（如 Nginx）进行保护，并考虑添加 API 密钥认证。
   • 内容过滤：在模型输出返回给用户前，增加一层内容安全过滤，防止生成有害信息。
   • 隐私保护：确保模型处理的数据不包含未脱敏的个人隐私信息。如果涉及，需进行匿名化处理。
   • 明确责任：在用户协议中明确说明 AI 生成内容的特点和可能存在的误差。

10. 总结与下一步

LFM2.5-2.6B 作为一个开源的端侧智能体模型，其最大的价值在于提供了一个可在本地私有化部署、且具备工具调用能力的轻量级 AI 基座。对于想要探索智能体应用、又对数据隐私和成本有要求的团队和个人来说，它是一个非常值得尝试的起点。

最值得尝试的点：

• 低门槛本地运行：8GB 显存的要求使得大部分开发者都能在自己的机器上体验。
• 真正的工具调用：不仅仅是对话，它能将自然语言指令转化为结构化的工具调用请求，这是实现自动化的关键一步。
• 开放的商业许可：允许商业使用，为产品集成提供了法律基础。

最先应该验证的功能：

1. 基础对话：确认模型的中文理解和生成能力是否符合你的基础预期。
2. 工具调用 Prompt 工程：按照本文示例，构建清晰、具体的工具描述，并测试模型是否能稳定地输出正确的调用格式。
3. 资源占用评估：在你的目标硬件上运行性能测试脚本，评估响应速度和并发能力。

最容易踩的坑：

1. 环境配置：Python 版本、PyTorch 版本与 CUDA 版本的匹配是第一步，也是最容易出错的一步。
2. 显存溢出 (OOM)：初次运行时，务必从小的max_new_tokens和batch_size开始。
3. 工具调用安全：切勿让模型拥有过高系统权限，务必在沙箱中测试危险操作。

后续可以扩展的方向：

• 集成到现有系统：将模型封装成微服务，集成到你的业务后台或桌面应用中。
• 构建复杂 Agent 工作流：结合 LangChain、AutoGen 等框架，实现多步骤规划、记忆和工具组合调用。
• 领域微调 (Fine-tuning)：如果你有特定领域的数据，可以对模型进行微调，提升其在专业任务上的表现和工具调用准确性。
• 探索量化与优化：尝试 4/8-bit 量化，或使用 ONNX、TensorRT 进行推理优化，以追求极致的性能和资源效率。

建议将本文中的关键代码和配置收藏备用。在实际部署中，耐心调试和迭代提示词（Prompt）是提升模型表现最有效的方法之一。现在，你可以开始你的端侧智能体之旅了。