Python 原生封装 Llama.cpp 大模型推理接口

眞bilibili

179人浏览 · 2026-08-26 19:00:34

眞bilibili · 2026-08-26 19:00:34 发布

什么是GGUF格式
首先 GGUF 是 llama.cpp 项目作者 Georgi Gerganov 于 2023 年 8 月 21 日推出的大模型文件存储格式标准，用于替代老旧的 GGML 格式。原始大模型（如 Llama、Qwen、Mistral 等）由各厂商完成训练，并以 Hugging Face PyTorch 格式发布原版权重。开发者需要借助 llama.cpp 提供的转换工具，将 HF 原版权重转换导出为 GGUF 文件，模型才能够在 llama.cpp 生态中完成本地推理运行。

与 GGML 格式不同 GGUF 格式将模型权重、分词器、各类模型配置参数全部封装打包到单个.gguf文件当中，相比前代格式，GGUF 拥有更广的兼容性、更快的模型加载速度、更低的内存开销以及更强的推理稳定性，现已成为大模型本地轻量化部署的主流优选格式。

针对 Ollama 框架，其底层推理引擎直接复用 llama.cpp，同时在 llama.cpp 的基础上封装扩展了模型拉取、版本管理、模型调用等一系列能力，降低使用门槛，便于开发者快速搭建私有化的大模型推理服务。

模型参数规模
简单理解参数量代表模型的规模，在同一模型系列、训练质量相近的前提下，参数量越大，知识储备、逻辑推理、复杂任务处理能力越强；但代价也同步上升，比如模型文件体积更大，运行需要的内存/显存更多，推理速度会变慢；但参数量也不是唯一评判标准，不同架构、不同训练数据的模型，即使参数量相同，实际效果差距也可能很大；部分经过精细微调的小模型，表现也有可能优于普通大参数量模型。

通常情况下大模型参数以Billion（亿）为单位，1B ≈10 亿参数，能够接触到并最常见的大模型参数量范围如下：

1B = 1 Billion ≈10 亿参数
2B = 2 Billion ≈20 亿参数
3B = 3 Billion ≈30 亿参数
4B = 4 Billion ≈40 亿参数
7B = 7 Billion ≈70 亿参数
8B = 8 Billion ≈80 亿参数
14B = 14 Billion ≈140 亿参数
20B = 20 Billion ≈200 亿参数
34B = 34 Billion ≈340 亿参数
70B = 70 Billion ≈700 亿参数
模型量化仅对权重数值做压缩处理，不会改变模型本身网络结构，模型原生能力上限保持不变，仅实际推理精度受到损耗。量化属于权衡取舍，用可接受的少量效果损失，换取更小的存储占用、更低硬件门槛以及更快推理速度。实际使用时，优先选择 Q4_K_M、Q5_K_M、Q6_K、Q8_0 这类成熟量化版本，不建议日常使用 Q2、Q3 这类低质量量化，容易产生大量幻觉和错误回答。

非量化（FP16 / BF16 原版）：原始精度权重，每个参数用 16 位浮点数保存。

优点：效果最好，几乎无损，推理质量最高
缺点：体积巨大，吃内存显存，硬件要求高。比如 8B 模型 FP16 大约 16GB。
量化 GGUF（Q4_K_M、Q5_K_M、Q8_0 这类）：把模型权重数值压缩，用更少比特存储一个参数。

优点：文件体积大幅缩小，内存 / 显存占用降低，普通电脑也能跑；速度更快。
缺点：会损失一小部分精度；量化等级越低（Q2、Q3）压缩越强，模型回答越容易胡言乱语。
若要本地部署可以参考以下参数量范围：

1‑4B：低配电脑、笔记本，适合简单问答、文本摘要等轻量任务
显存：最低 2‑3GB；核显也可运行
系统内存：最低 8GB，推荐 16GB
参考显卡：GTX1650、RTX3050，轻薄本核显可跑
7‑8B：家用电脑主流选择，推理效果与硬件消耗较为均衡
显存：最低 4‑6GB，推荐 8‑12GB
系统内存：最低 12GB，推荐 16GB
参考显卡：RTX3060 12G、RTX4060；8G 显存显卡可跑
14‑20B：需要较好显存支持，逻辑推理能力相比小模型有明显提升
显存：最低 9‑10GB，推荐 16GB 以上显存
系统内存：最低 24GB，推荐 32GB
参考显卡：RTX4060Ti‑16G、RTX3090 12G
34B 及以上：硬件门槛较高，适合高性能台式机运行
显存：Q4_K_M 最低 18‑20GB，推荐 24GB 及以上
系统内存：最低 32GB，推荐 64GB
参考显卡：RTX3090/4090（24G）、RTX5090（32G）
查询模型信息
gguf 是适配 Llama.cpp 生态的官方Python解析工具模块，专门用于读取、解析 GGUF 格式量化大模型文件，是本地离线部署GGUF模型的基础依赖库，执行以下终端命令完成依赖一键安装：

CMD> pip install -i https://pypi.tuna.tsinghua.edu.cn/simple gguf
下文提供全自动Python解析脚本，无需手动配置参数，可一键读取本地GGUF模型文件，完整输出模型基础信息、网络超参、分词器配置、张量统计、量化参数等全维度数据，适配所有主流GGUF格式大模型。

import os
import sys
from gguf import GGUFReader

if name == “main”:
if len(sys.argv) < 2:
sys.exit(1)

model_path = sys.argv[1]
if not os.path.exists(model_path):
    print(f"错误：文件不存在 -> {model_path}")
    sys.exit(1)

reader = GGUFReader(model_path)
meta = {}
for k, field in reader.fields.items():
    meta[k] = field.contents()

file_size_bytes = os.path.getsize(model_path)
file_size_gb = file_size_bytes / (1024 ** 3)
arch = meta.get("general.architecture")

GGML_TYPE_MAP = {
    0: "F32",
    1: "F16",
    2: "Q4_0",
    3: "Q4_1",
    6: "Q5_0",
    7: "Q5_1",
    8: "Q8_0",
    9: "Q8_1",
    10: "Q8_K",
    11: "Q6_K",
    12: "Q4_K",
    13: "Q5_K",
    14: "Q6_K",
    15: "Q2_K",
    16: "Q3_K",
    17: "IQ3_K_S",
    18: "IQ3_K_M",
    19: "IQ3_K_L",
    20: "IQ2_K_S",
    21: "IQ2_K_M",
}

model_filename = os.path.basename(model_path)
total_param_count = 0
for tensor in reader.tensors:
    cnt = 1
    for dim in tensor.shape:
        cnt *= dim
    total_param_count += cnt
total_param_b = total_param_count / 1e9

print("-" * 80)
print("[GGUF 文件整体信息]")
print("-" * 80)
print(f"文件名称         : {model_filename}")
print(f"文件大小         : {file_size_gb:.3f} GB  ({file_size_bytes:,} bytes)")
print(f"GGUF版本         : {meta.get('general.file_version')}")
print(f"GGUF内部version  : {meta.get('GGUF.version')}")
print(f"文件类型(量化)   : {meta.get('general.file_type')}")
print(f"量化版本         : {meta.get('general.quantization_version')}")
print(f"模型原始总参数量 : {total_param_count:,} ≈ {total_param_b:.2f} B")

print("\n" + "-" * 80)
print("[模型基础通用信息 general.*]")
print("-" * 80)
print(f"模型名称         : {meta.get('general.name')}")
print(f"模型厂商         : {meta.get('general.author')}")
print(f"参数量标签       : {meta.get('general.size_label')}")
print(f"模型架构         : {meta.get('general.architecture')}")
print(f"模型版本         : {meta.get('general.version')}")
print(f"许可 License     : {meta.get('general.license')}")
print(f"来源URL          : {meta.get('general.source_url')}")
print(f"来源HuggingFace  : {meta.get('general.source_hf')}")
print(f"描述 description : {meta.get('general.description')}")
print(f"量化工具         : {meta.get('general.quantization_tool')}")
print(f"量化工具版本     : {meta.get('general.quantization_tool_version')}")

print("\n" + "-" * 80)
print(f"[模型网络超参 {arch}.*]")
print("-" * 80)
print(f"block_count(层数)          : {meta.get(f'{arch}.block_count')}")
print(f"embedding_length(隐层dim)  : {meta.get(f'{arch}.embedding_length')}")
print(f"feed_forward_length(FFN)   : {meta.get(f'{arch}.feed_forward_length')}")
print(f"context_length(训练上下文) : {meta.get(f'{arch}.context_length')}")
print(f"head_count(总注意力头)     : {meta.get(f'{arch}.attention.head_count')}")
print(f"key_value_head_count(KV头) : {meta.get(f'{arch}.attention.head_count_kv')}")
print(f"rope.dimension_count(RoPE维度): {meta.get(f'{arch}.rope.dimension_count')}")
print(f"rope.freq_base(RoPE theta) : {meta.get(f'{arch}.rope.freq_base')}")
print(f"rope.scaling_type          : {meta.get(f'{arch}.rope.scaling_type')}")
print(f"rope.scaling_factor        : {meta.get(f'{arch}.rope.scaling_factor')}")
print(f"rope.ext_factor            : {meta.get(f'{arch}.rope.ext_factor')}")
print(f"rope.attn_factor           : {meta.get(f'{arch}.rope.attn_factor')}")
print(f"rope.finetune              : {meta.get(f'{arch}.finetune')}")
print(f"norm_epsilon(RMS‑eps)      : {meta.get(f'{arch}.attention.layer_norm_rms_epsilon')}")
print(f"attention.dropout          : {meta.get(f'{arch}.attention.dropout')}")

attn_head = meta.get(f"{arch}.attention.head_count")
attn_kv_head = meta.get(f"{arch}.attention.head_count_kv")
attn_norm_eps = meta.get(f"{arch}.attention.layer_norm_rms_epsilon")

print(f"attention.head_count      : {attn_head}")
print(f"attention.head_count_kv   : {attn_kv_head}")
print(f"attention.layer_norm_rms_epsilon : {attn_norm_eps}")

print(f"\n>>> MoE混合专家(普通模型为None)")
print(f"expert_count(专家总数)     : {meta.get(f'{arch}.expert_count')}")
print(f"expert_used_count(激活数)  : {meta.get(f'{arch}.expert_used_count')}")

print("\n" + "-" * 80)
print("[Tokenizer 分词器配置 tokenizer.ggml.*]")
print("-" * 80)
print(f"vocab_size(词表大小)       : {meta.get('tokenizer.ggml.vocab_size')}")
print(f"BOS token id               : {meta.get('tokenizer.ggml.bos_token_id')}")
print(f"EOS token id               : {meta.get('tokenizer.ggml.eos_token_id')}")
print(f"PAD token id               : {meta.get('tokenizer.ggml.pad_token_id')}")
print(f"UNK token id               : {meta.get('tokenizer.ggml.unk_token_id')}")
print(f"SEP token id               : {meta.get('tokenizer.ggml.sep_token_id')}")
print(f"CLS token id               : {meta.get('tokenizer.ggml.cls_token_id')}")
print(f"MASK token id              : {meta.get('tokenizer.ggml.mask_token_id')}")

chat_template = meta.get("tokenizer.ggml.chat_template")
chat_template_alt = meta.get("tokenizer.chat_template")
if chat_template:
    print("\n>>> Chat Template(Jinja2对话模板‑ggml)")
    print(chat_template)
elif chat_template_alt:
    print("\n>>> Chat Template(Jinja2对话模板‑tokenizer)")
    print(chat_template_alt)

special_tokens_list = meta.get("tokenizer.ggml.special_tokens")
if special_tokens_list is not None:
    print(f"\n>>> 特殊token列表数量: {len(special_tokens_list)}")

print("\n" + "-" * 80)
print("[张量统计信息]")
print("-" * 80)
total_tensors = len(reader.tensors)
print(f"张量总数量: {total_tensors}")

dtype_counter = {}
total_weights_elements = 0
for tensor in reader.tensors:
    dtype_counter[tensor.tensor_type] = dtype_counter.get(tensor.tensor_type, 0) + 1
    ele_cnt = 1
    for s in tensor.shape:
        ele_cnt *= s
    total_weights_elements += ele_cnt

print(f"权重元素总个数: {total_weights_elements:,}")
print("各张量类型计数(原始数字 + 可读类型):")
for dt, cnt in dtype_counter.items():
    dt_name = GGML_TYPE_MAP.get(dt, "UNKNOWN")
    print(f"  {dt} ({dt_name:<8}) : {cnt} 个张量")

print("\n>>> 前8个张量信息展示：")
for t in reader.tensors[:8]:
    shape_str = str(t.shape)
    dt_name = GGML_TYPE_MAP.get(t.tensor_type, "UNKNOWN")
    print(f"  {t.name:<55} shape:{shape_str:<25} dtype:{t.tensor_type:2d}({dt_name})")

n_layer = meta.get(f"{arch}.block_count")
n_embd = meta.get(f"{arch}.embedding_length")
ff_dim = meta.get(f"{arch}.feed_forward_length")
if n_layer and n_embd and ff_dim:
    print("\n>>> 简易Transformer层估算(不含embedding/output层，仅作对比)")
    est_params = n_layer * (2 * n_embd * n_embd + ff_dim * n_embd)
    est_billion = est_params / 1e9
    print(f"估算参数量(仅transformer层): {est_params:,} ≈ {est_billion:.2f} B")

print("\n" + "-" * 80)
print("[元数据字段总览]")
print("-" * 80)
all_meta_keys = list(meta.keys())
print(f"GGUF文件内元数据总字段数量：{len(all_meta_keys)}")
print("\n全部元数据key列表：")
for key in sorted(all_meta_keys):
    print(f"  {key}")

将上述代码保存文件，放置于本地模型文件同级目录，将命令中的模型路径替换为本地GGUF模型绝对路径，执行以下终端命令运行脚本：

CMD> python main.py C://llamacpp/qwen2.5-1.5b-instruct-q4_k_m.gguf
执行接口调用
1、承接《Windows 环境下 llama.cpp 编译运行指南》部分内容，通过命令工具llama‑server启动服务，端口监听127.0.0.1:11433，并加载 qwen2.5‑1.5b‑instruct‑q4_k_m.gguf 模型，确保本地服务已经启动。

CMD> llama-server.exe -m qwen2.5-1.5b-instruct-q4_k_m.gguf --host 127.0.0.1 --port 11433 -c 4096
CMD>
init: llama threadpool init, n_threads = 12
load_model: initializing, n_slots = 4, n_ctx_slot = 4096, kv_unified = ‘true’
llama_server: model loaded
llama_server: listening on http://127.0.0.1:11433
2、完成模型解析与环境校验后，即可基于Llama.cpp本地服务实现基础对话功能。本模块全程使用Python原生urllib+json库开发，无任何第三方框架依赖，通过向本地11433端口服务发起POST请求实现模型推理。

import json
import urllib.request
import urllib.error

class Config:
LLM_BASE_URL = “http://127.0.0.1:11433”
LLM_MODEL = “qwen2.5-1.5b-instruct-q4_k_m.gguf”
LLM_TEMPERATURE = 0.8
LLM_MAX_TOKENS = 1024
LLM_CTX_SIZE = 4096
LLM_STOP_WORDS = [“<|im_end|>”]
TIMEOUT_SECONDS = 30

class LlamaCppClient:
def init(self):
self.base_url = Config.LLM_BASE_URL
self.model = Config.LLM_MODEL
self.temperature = Config.LLM_TEMPERATURE
self.max_tokens = Config.LLM_MAX_TOKENS
self.ctx_size = Config.LLM_CTX_SIZE
self.stop = Config.LLM_STOP_WORDS
self.timeout = Config.TIMEOUT_SECONDS

def generate(self, prompt: str) -> str:
    url = f"{self.base_url}/completion"
    headers = {"Content-Type": "application/json"}
    payload = {
        "model": self.model,
        "prompt": prompt,
        "temperature": self.temperature,
        "max_tokens": self.max_tokens,
        "ctx_size": self.ctx_size,
        "stop": self.stop,
        "stream": False
    }
    try:
        req = urllib.request.Request(
            url,
            data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
            headers=headers,
            method="POST"
        )
        with urllib.request.urlopen(req, timeout=self.timeout) as resp:
            data = json.loads(resp.read().decode("utf-8"))
            return data.get("content", "").strip()
    except urllib.error.URLError as e:
        return f"[错误] llama.cpp服务连接失败:{str(e)}"
    except json.JSONDecodeError:
        return "[错误] 返回非合法JSON"
    except Exception as e:
        return f"[错误] {str(e)}"

if name == “main”:
llm = LlamaCppClient()

# 拼接提示词
system_text = "你是一个专业的助手，能够回答用户的问题。"
user_input = "你好，简单介绍一下自己"

prompt = (
    f"<|im_start|>system\n{system_text}<|im_end|>\n"
    f"<|im_start|>user\n{user_input}<|im_end|>\n"
    f"<|im_start|>assistant\n"
)

# 调用模型生成回复
reply = llm.generate(prompt)
print(f"AI：{reply}\n")

执行以下终端命令运行脚本：

CMD> python main.py

AI：我是阿里云开发的一款超大规模语言模型，我叫通义千问。
实现内存记忆
上一模块的基础单次对话为无状态推理，模型无法记忆历史对话内容，多轮交互时上下文断裂、对话逻辑脱节，无法满足日常人机交互需求。

本模块自定义轻量化ChatMemory对话内存类，通过列表结构化存储系统提示词、用户提问、助手回复等完整对话记录，自动拼接标准化完整提示词，实现永久上下文记忆、手动清空记忆、持续多轮对话功能，完美模拟在线AI对话交互逻辑。

该内存方案无需数据库存储，纯内存运行、轻量化无冗余，适配本地离线部署场景，同时预留拓展接口，可后续新增文件持久化记忆功能

import json
import urllib.request
import urllib.error
from typing import List, Dict

def generate(self, prompt: str) -> str:
    url = f"{self.base_url}/completion"
    headers = {"Content-Type": "application/json"}
    payload = {
        "model": self.model,
        "prompt": prompt,
        "temperature": self.temperature,
        "max_tokens": self.max_tokens,
        "ctx_size": self.ctx_size,
        "stop": self.stop,
        "stream": False
    }
    try:
        req = urllib.request.Request(
            url,
            data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
            headers=headers,
            method="POST"
        )
        with urllib.request.urlopen(req, timeout=self.timeout) as resp:
            data = json.loads(resp.read().decode("utf-8"))
            return data.get("content", "").strip()
    except urllib.error.URLError as e:
        return f"[错误] llama.cpp服务连接失败:{str(e)}"
    except json.JSONDecodeError:
        return "[错误] 返回非合法JSON"
    except Exception as e:
        return f"[错误] {str(e)}"

对话内存实现方式：基于列表的简单记忆

class ChatMemory:
def init(self):
self.history: List[Dict[str, str]] = []

def add_user(self, content: str):
    self.history.append({"role":"user","content":content})

def add_assistant(self, content: str):
    self.history.append({"role":"assistant","content":content})

def clear(self):
    self.history.clear()

def build_prompt(self, system_content:str) -> str:
    prompt = f"<|im_start|>system\n{system_content}<|im_end|>\n"
    for msg in self.history:
        prompt += f"<|im_start|>{msg['role']}\n{msg['content']}<|im_end|>\n"
    prompt += "<|im_start|>assistant\n"
    return prompt

if name == “main”:
llm = LlamaCppClient()
memory = ChatMemory()

system_prompt = "你是一个专业的助手，能够回答用户的问题。"

while True:
    user_in = input("你：").strip()
    if not user_in:
        continue
    if user_in in ("q","quit","exit","退出"):
        break
    if user_in == "clear":
        memory.clear()
        print("已清空对话记忆\n")
        continue

    memory.add_user(user_in)

    # 构建提示词
    prompt = memory.build_prompt(system_prompt)

    # 调用LLM生成回复
    resp = llm.generate(prompt)

    # 写入内存
    memory.add_assistant(resp)
    print(f"AI：{resp}\n")

执行以下终端命令运行脚本：https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E4%BD%A0%E8%BD%AC%E8%BA%AB%E6%97%B6%E7%A7%8B%E9%9B%A8%E6%B5%B8%E9%80%8F%E6%89%80%E6%9C%89%E5%85%89.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E9%92%9F%E4%B9%B3%E7%9F%B3%E6%BB%B4%E8%90%BD%E5%87%9D%E5%9B%BA%E7%9A%84%E5%8D%83%E5%B9%B4%E5%BF%83%E8%B7%B3.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E5%86%B0%E5%B7%9D%E8%A3%82%E9%9A%99%E6%B8%97%E5%87%BA%E8%93%9D%E8%89%B2%E7%9A%84%E5%8F%B2%E5%89%8D%E5%8F%B9%E6%81%AF.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E4%BD%A0%E5%8F%91%E9%97%B4%E6%AE%8B%E7%95%99%E7%9A%84%E5%A4%8F%E6%97%A5%E9%A6%99%E6%B0%94.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E8%8C%B6%E6%B1%A4%E9%87%8C%E6%B2%89%E6%B5%AE%E7%9D%80%E5%B1%B1%E7%9A%84%E5%80%92%E5%BD%B1.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E8%90%A4%E7%81%AB%E8%99%AB%E7%82%B9%E4%BA%AE%E6%98%9F%E5%9B%BE%E7%9A%84%E7%BC%BA%E5%8F%A3.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%B5%B7%E6%B5%AA%E5%B0%86%E8%B4%9D%E5%A3%B3%E7%A3%A8%E6%88%90%E8%8B%8D%E7%99%BD%E8%AE%B0%E5%BF%86.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E7%93%B7%E7%93%B6%E8%A3%82%E7%BA%B9%E9%87%8C%E6%B8%97%E5%87%BA%E5%89%8D%E6%9C%9D%E7%9A%84%E6%A2%85%E9%A6%99.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E7%81%AB%E6%9F%B4%E6%93%A6%E4%BA%AE%E6%97%B6%E7%85%A7%E4%BA%AE%E6%95%B4%E7%89%87%E9%93%B6%E6%B2%B3%E7%9A%84%E8%8D%92%E8%8A%9C.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E9%9B%A8%E6%BB%B4%E7%A9%BF%E9%80%8F%E7%99%BE%E5%B9%B4%E7%9F%B3%E9%98%B6%E7%9A%84%E5%8F%B9%E6%81%AF.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E5%86%B0%E5%B7%9D%E5%9C%A8%E8%80%B3%E8%AF%AD%E4%B8%AD%E5%B4%A9%E8%A3%82%E6%88%90%E7%BE%A4%E5%B2%9B.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E5%80%99%E9%B8%9F%E7%BE%BD%E7%BF%BC%E6%8E%A0%E8%BF%87%E5%87%9D%E5%9B%BA%E6%97%B6%E7%A9%BA.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E9%9B%A8%E6%BB%B4%E7%A9%BF%E9%80%8F%E7%90%B4%E5%BC%A6%E5%94%A4%E9%86%92%E6%97%A7%E6%97%B6%E5%85%89.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%B5%B7%E6%B5%AA%E5%B0%86%E7%A4%81%E7%9F%B3%E9%9B%95%E7%90%A2%E6%88%90%E5%AD%A4%E7%8B%AC.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%B5%81%E6%98%9F%E7%84%9A%E7%83%A7%E5%90%8E%E4%BD%99%E7%83%AC%E5%9D%A0%E5%85%A5%E7%9E%B3%E5%AD%94.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E7%9B%90%E7%A2%B1%E5%9C%B0%E6%B8%97%E5%87%BA%E5%A4%A7%E5%9C%B0%E5%B9%B2%E6%B6%B8%E7%9A%84%E6%B3%AA%E7%97%95.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E4%BD%A0%E8%BD%AC%E8%BA%AB%E6%97%B6%E7%8E%AB%E7%91%B0%E8%A4%AA%E8%89%B2%E4%B8%BA%E7%81%B0%E7%83%AC.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E7%83%9B%E7%81%AB%E5%9C%A8%E9%A3%8E%E4%B8%AD%E5%86%99%E4%B8%8B%E9%A2%A4%E6%8A%96%E7%BB%93%E5%B1%80.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%9E%AF%E5%8F%B6%E6%B2%89%E5%85%A5%E6%B1%A0%E5%BA%95%E5%8C%96%E4%BD%9C%E6%98%9F%E8%BE%B0.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%B5%81%E6%98%9F%E9%9B%A8%E6%B7%B9%E6%B2%A1%E6%89%80%E6%9C%89%E6%9C%AA%E7%AB%9F%E8%AF%9D%E8%AF%AD.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E8%AA%93%E8%A8%80%E6%B2%89%E5%85%A5%E6%B5%B7%E5%BA%95%E5%8C%96%E4%BD%9C%E7%8F%8A%E7%91%9A%E7%A4%81.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E7%BA%B8%E8%88%B9%E8%BD%BD%E7%9D%80%E7%A3%B7%E7%81%AB%E7%A9%BF%E8%B6%8A%E5%86%A5%E6%B2%B3.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E5%80%99%E9%B8%9F%E7%94%A8%E5%BD%B1%E5%AD%90%E7%BC%9D%E5%90%88%E4%BA%91%E5%B1%82%E7%9A%84%E8%A3%82%E4%BC%A4.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E9%99%A8%E7%9F%B3%E5%9D%91%E9%87%8C%E5%AD%B5%E7%9D%80%E7%A0%B4%E7%A2%8E%E7%9A%84%E6%9C%88%E5%85%89.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E4%BD%A0%E5%BE%AE%E7%AC%91%E6%97%B6%E7%9A%84%E6%B8%A9%E5%BA%A6%E5%9C%A8%E8%A4%AA%E8%89%B2.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E7%9B%90%E7%A2%B1%E5%9C%B0%E6%9E%90%E5%87%BA%E5%A4%A7%E5%9C%B0%E7%9A%84%E9%AA%A8%E7%81%B0.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E9%9C%9C%E8%8A%B1%E5%9C%A8%E9%BB%8E%E6%98%8E%E5%89%8D%E6%82%84%E7%84%B6%E6%B6%88%E9%80%9D.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%97%B6%E9%92%88%E5%9C%A8%E8%A1%A8%E7%9B%98%E5%95%83%E9%A3%9F%E8%87%AA%E5%B7%B1%E7%9A%84%E5%BD%B1%E5%AD%90.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%B5%81%E6%98%9F%E7%84%9A%E5%B0%BD%E6%9C%80%E5%90%8E%E7%9A%84%E8%AF%BA%E8%A8%80.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E8%96%84%E9%9B%BE%E8%BD%BB%E5%90%BB%E5%B1%B1%E5%B3%A6%E8%BD%AE%E5%BB%93%E6%B8%90%E6%B8%A9%E6%9F%94.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%9A%97%E9%A6%99%E6%B5%AE%E5%8A%A8%E5%9C%A8%E6%9C%AA%E5%AF%84%E5%87%BA%E7%9A%84%E4%BF%A1%E7%BA%B8.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E7%83%9B%E6%B3%AA%E5%87%9D%E5%9B%BA%E6%88%90%E7%90%A5%E7%8F%80%E8%89%B2%E7%9A%84%E5%8F%B9%E6%81%AF.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E4%BF%A1%E7%BA%B8%E6%8A%98%E7%97%95%E5%A4%84%E6%9A%97%E8%97%8F%E7%9A%84%E6%98%9F%E5%9B%BE.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%B5%81%E6%98%9F%E6%8A%8A%E7%81%B0%E7%83%AC%E6%92%92%E5%90%91%E5%A4%B1%E7%9C%A0%E7%9A%84%E9%BA%A6%E7%94%B0.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E9%99%B6%E7%BD%90%E8%A3%82%E7%BA%B9%E6%B8%B8%E8%B5%B0%E7%9D%80%E8%9C%88%E8%9A%A3%E5%BD%A2%E7%9A%84%E6%9A%AE%E8%89%B2.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%8C%87%E7%BA%B9%E5%9C%A8%E6%9D%AF%E6%B2%BF%E7%95%99%E4%B8%8B%E8%A4%AA%E8%89%B2%E8%AF%81%E6%8D%AE.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%B5%81%E6%98%9F%E5%88%92%E8%BF%87%E5%A4%A9%E9%99%85%E7%82%B9%E7%87%83%E8%8D%92%E5%8E%9F.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E5%86%B0%E5%B7%9D%E7%9A%84%E8%A3%82%E9%9A%99%E6%B8%97%E5%87%BA%E8%BF%9C%E5%8F%A4%E7%9A%84%E7%9B%90.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%B2%99%E6%BC%A0%E6%9C%88%E5%85%89%E6%B5%81%E6%B7%8C%E6%88%90%E9%93%B6%E8%89%B2%E6%8C%BD%E6%AD%8C.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E6%9E%AF%E6%9E%9D%E5%9C%A8%E9%9B%AA%E5%9C%B0%E5%86%99%E4%B8%8B%E6%96%AD%E7%BB%AD%E8%AF%97%E5%8F%A5.md
https://github.com/zO2CkWKe31/memo-txzbe/blob/main/%E9%94%88%E8%9A%80%E7%9A%84%E5%88%80%E9%9E%98%E9%87%8C%E8%97%8F%E7%9D%80%E6%9C%AA%E8%AF%B4%E5%AE%8C%E7%9A%84%E8%AA%93%E8%A8%80.md

CMD> python main.py

你：你好，我叫王瑞
AI：你好，王瑞，很高兴认识你。

你：我叫什么，你知道吗
AI：你好，王瑞，很高兴认识你。

你：简单介绍下你自己
AI：我是来自阿里的智能机器人。我叫“小助手”。我可以回答各种各样的问题，提供你想要的信息。你有什么问题想问我吗？
实现工具调用
原生本地大模型存在天然能力短板：无法获取实时系统时间、无法精准运算复杂数学公式、无外部数据获取能力、静态知识存在滞后性，无法适配实用化落地场景。本模块基于前文记忆对话框架，拓展自定义工具调用系统，内置时间查询、数学计算器两大高频实用工具，通过正则匹配解析模型输出的标准化工具调用指令，自动执行本地工具函数、获取结果后二次调用模型，生成贴合用户需求的最终自然语言回复，完整实现「模型决策调用工具-本地执行工具-结果反馈模型」的闭环能力。

本工具框架高度可拓展，开发者可基于现有代码，快速新增天气查询、文件读取、文本翻译、代码运行、联网搜索等各类自定义工具，无需重构核心逻辑。同时兼容Qwen模型原生工具调用模板。

亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责