GLM-5.1 - comment l’exécuter localement

Exécutez le nouveau modèle GLM-5.1 de Z.ai sur votre propre appareil local !

GLM-5.1 est le nouveau modèle ouvert de Z.ai. Par rapport à GLM-5, il apporte des améliorations majeures en codage, en utilisation d'outils agentiques, en raisonnement, en jeu de rôle, dans les tâches agentiques à long horizon et dans la qualité globale du chat.

Le modèle complet GLM-5.1 de 744B de paramètres (40B actifs) a une fenêtre de contexte de 200K et nécessite 1.65TB d'espace disque. Unsloth Dynamic 2-bit GGUF réduit la taille à 220GB (-80%), et la version dynamique 1 bit fait 200GB (-85 %) : GLM-5.1-GGUF

Tous les téléversements utilisent Unsloth Dynamic 2.0 pour des performances de quantification de pointe - ainsi, les bits plus faibles ont leurs couches importantes remontées en 8 ou 16 bits. Merci à Z.ai d'avoir fourni à Unsloth un accès dès le jour zéro.

⚙️ Guide d'utilisation

La quantification dynamique moyenne en 2 bits UD-IQ2_M utilise 236GB d'espace disque - cela peut directement tenir sur un Mac avec 256 Go de mémoire unifiée et fonctionne bien sur un GPU 1x24 Go et 256 Go de RAM avec déchargement MoE. La 1 bit quantification tiendra dans 220GB de RAM et la version 8 bits nécessite 805GB de RAM.

Pour des performances optimales, assurez-vous que votre mémoire totale disponible (VRAM + RAM système) dépasse la taille du fichier du modèle quantifié que vous téléchargez. Si ce n'est pas le cas, llama.cpp peut toujours fonctionner via le déchargement sur SSD/HDD, mais l'inférence sera plus lente.

Paramètres recommandés

Utilisez des paramètres distincts pour différents cas d'utilisation :

Paramètres par défaut (la plupart des tâches)	Terminal Bench
température = 1.0	température = 0.7
top_p = 0.95	top_p = 1.0
max new tokens = 131072	max new tokens = 16384

• Fenêtre de contexte maximale : 202,752.

• Dans GLM-5.1, la réflexion est activée par défaut. Pour la désactiver :

    --chat-template-kwargs '{"enable_thinking":false}'

Mise à jour du modèle de conversation

GLM-5.1 adopte la même architecture que GLM-5, simplement chat_template.jinja est différent.

• Prend en charge l'outil de recherche de Claude. Les outils avec defer_loading=True sont omis de l'invite système et affichés à la place dans les résultats des outils.

• Autoriser des blocs de raisonnement vides (<think></think>) dans les messages de l'assistant. Les messages consécutifs de l'assistant doivent rester dans le même mode, soit en réflexion, soit sans réflexion.

• Globalement, GLM-5.1 améliore בעיקר l'exposition aux outils, la reconstruction de l'historique de raisonnement et le rendu des messages d'outils.

Exécuter les tutoriels GLM-5.1 :

Vous pouvez désormais exécuter GLM-5.1 dans llama.cpp et Unsloth Studio.

🦥 Exécuter dans Unsloth Studio

GLM-5.1 peut désormais s'exécuter dans Unsloth Studio, notre nouvelle interface web open source pour l’IA locale. Unsloth Studio vous permet d’exécuter des modèles localement sur MacOS, Windows, Linux et :

• Rechercher, télécharger, exécuter des GGUF et des modèles safetensor

• Auto-réparation appel d'outils + recherche web

• Exécution de code (Python, Bash)

• Inférence automatique réglage des paramètres (temp, top-p, etc.)

• Utilise llama.cpp pour une inférence rapide CPU + GPU et le déchargement CPU

1

Installer Unsloth

Exécutez dans votre terminal :

macOS, Linux, WSL :

curl -fsSL https://unsloth.ai/install.sh | sh

Windows PowerShell :

irm https://unsloth.ai/install.ps1 | iex

2

Lancer Unsloth

MacOS, Linux, WSL et Windows :

unsloth studio -H 0.0.0.0 -p 8888

Puis ouvrez http://localhost:8888 dans votre navigateur.

3

Rechercher et télécharger GLM-5.1

Lors du premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard. Vous verrez ensuite un bref assistant d'intégration pour choisir un modèle, un jeu de données et des paramètres de base. Vous pouvez le passer à tout moment.

Vous pouvez choisir UD-Q2_K_XL (quantification dynamique 2 bits) ou d'autres versions quantifiées comme UD-Q4_K_XL . Nous recommandons d'utiliser notre quantification dynamique 2 bits UD-Q2_K_XL pour équilibrer taille et précision. Si les téléchargements se bloquent, consultez Dépannage de Hugging Face Hub et XET

Puis allez dans l’onglet Unsloth Chat onglet et recherchez GLM-5.1 dans la barre de recherche et téléchargez le modèle et la quantification souhaités. Le téléchargement prendra un certain temps en raison de la taille, alors veuillez patienter. Pour garantir une inférence rapide, assurez-vous d'avoir suffisamment de RAM/VRAM, sinon l'inférence fonctionnera toujours, mais Unsloth la déchargera vers votre CPU.

4

Exécuter GLM-5.1

Les paramètres d'inférence doivent être définis automatiquement lors de l'utilisation d'Unsloth Studio ; toutefois, vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur de contexte, le gabarit de conversation et d'autres paramètres.

Pour plus d'informations, vous pouvez consulter notre Guide d'inférence Unsloth Studio.

🦙 Exécuter dans llama.cpp

1

Obtenez la dernière version de llama.cpp sur GitHub ici. Vous pouvez également suivre les instructions de compilation ci-dessous. Remplacez -DGGML_CUDA=ON par -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement une inférence sur CPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis continuez comme d'habitude - la prise en charge de Metal est activée par défaut.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

2

Si vous souhaitez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:IQ2_M) est le type de quantification. Vous pouvez également télécharger via Hugging Face (point 3). Cela ressemble à ollama run . Utilisez export LLAMA_CACHE="folder" pour forcer llama.cpp pour l'enregistrer dans un emplacement spécifique. N'oubliez pas que le modèle a seulement une longueur de contexte maximale de 200K.

Suivez ceci pour des instructions générales cas d'utilisation :

export LLAMA_CACHE="unsloth/GLM-5.1-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/GLM-5.1-GGUF:UD-IQ2_M \\
    --ctx-size 16384 \\
    --temp 0.7 \
    --top-p 1.0

Suivez ceci pour appel d'outils cas d'utilisation :

export LLAMA_CACHE="unsloth/GLM-5.1-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/GLM-5.1-GGUF:UD-IQ2_M \\
    --ctx-size 16384 \\
    --temp 1.0 \
    --top-p 0.95

3

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir UD-Q2_K_XL (quantification dynamique 2 bits) ou d'autres versions quantifiées comme UD-Q4_K_XL . Nous recommandons d'utiliser notre quantification dynamique 2 bits UD-Q2_K_XL pour équilibrer taille et précision. Si les téléchargements se bloquent, consultez Dépannage de Hugging Face Hub et XET

pip install -U huggingface_hub
hf download unsloth/GLM-5.1-GGUF \\
    --local-dir unsloth/GLM-5.1-GGUF \\
    --include "*UD-IQ2_M*" # Utilisez "*UD-TQ1_0*" pour le 1 bit dynamique

4

Vous pouvez modifier --threads 32 pour le nombre de threads CPU, --ctx-size 16384 pour la longueur du contexte, --n-gpu-layers 2 pour le déchargement GPU sur le nombre de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous n'avez qu'une inférence CPU.

./llama.cpp/llama-cli \
    --model unsloth/GLM-5.1-GGUF/UD-IQ2_M/GLM-5.1-UD-IQ2_M-00001-of-00006.gguf \\
    --temp 1.0 \
    --top-p 0.95 \
    --ctx-size 16384 \\
    --seed 3407

🦙 Llama-server pour le service et la bibliothèque de complétion d'OpenAI

Pour déployer GLM-5.1 en production, nous utilisons llama-server Dans un nouveau terminal, par exemple via tmux, déployez le modèle avec :

./llama.cpp/llama-server \
    --model unsloth/GLM-5.1-GGUF/UD-IQ2_M/GLM-5.1-UD-IQ2_M-00001-of-00006.gguf \\
    --alias "unsloth/GLM-5.1" \\
    --prio 3 \\
    --temp 1.0 \
    --top-p 0.95 \
    --ctx-size 16384 \\
    --port 8001

Ensuite, dans un nouveau terminal, après avoir effectué pip install openai, faites :

from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/GLM-5.1",
    messages = [{"role": "user", "content": "Crée un jeu Snake."},],
)
print(completion.choices[0].message.content)

Vous pouvez ensuite appeler le modèle servi via l'API OpenAI :

from openai import AsyncOpenAI, OpenAI
openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8001/v1"
client = OpenAI( # ou AsyncOpenAI
    api_key = openai_api_key,
    base_url = openai_api_base,
)

🔨Appel d'outils avec GLM-5.1

Voir Tool Calling Guide pour plus de détails sur la manière de faire appel aux outils. Dans un nouveau terminal (si vous utilisez tmux, utilisez CTRL+B+D), nous créons quelques outils comme l'addition de 2 nombres, l'exécution de code Python, l'exécution de fonctions Linux et bien plus encore :

import json, subprocess, random
from typing import Any
def add_number(a: float | str, b: float | str) -> float:
    return float(a) + float(b)
def multiply_number(a: float | str, b: float | str) -> float:
    return float(a) * float(b)
def subtract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "Il y a très longtemps, dans une galaxie très, très lointaine...",
        "Il y avait 2 amis qui aimaient les paresseux et le code...",
        "Le monde touchait à sa fin parce que chaque paresseux avait évolué pour avoir une intelligence surhumaine...",
        "À l'insu de l'un des amis, l'autre a accidentellement codé un programme pour faire évoluer les paresseux...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Impossible d'exécuter les commandes 'rm, sudo, dd, chmod' car elles sont dangereuses"
        print(msg); return msg
    print(f"Exécution de la commande de terminal `{command}`")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"Échec de la commande : {e.stderr}"
def python(code: str) -> str:
    data = {}
    exec(code, data)
    del data["__builtins__"]
    return str(data)
MAP_FN = {
    "add_number": add_number,
    "multiply_number": multiply_number,
    "subtract_number": subtract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "Ajoute deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "Multiplie deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "subtract_number",
            "description": "Soustrait deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_a_story",
            "description": "Écrit une histoire aléatoire.",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "Effectue des opérations depuis le terminal.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "La commande que vous souhaitez lancer, par ex. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Appelle un interpréteur Python avec du code Python qui sera exécuté.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "Le code Python à exécuter",
                    },
                },
                "required": ["code"],
            },
        },
    },
]

Nous utilisons ensuite les fonctions ci-dessous (copier-coller et exécuter), qui analyseront automatiquement les appels de fonctions et appelleront le point de terminaison OpenAI pour n'importe quel modèle :

from openai import OpenAI
def unsloth_inference(
    messages,
    temperature = 1.0,
    top_p = 0.95,
    top_k = -1,
    min_p = 0.01,
    repetition_penalty = 1.0,
):
    messages = messages.copy()
    openai_client = OpenAI(
        base_url = "http://127.0.0.1:8001/v1",
        api_key = "sk-no-key-required",
    )
    model_name = next(iter(openai_client.models.list())).id
    print(f"Modèle utilisé = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Messages actuels = {messages}")
        response = openai_client.chat.completions.create(
            model = model_name,
            messages = messages,
            temperature = temperature,
            top_p = top_p,
            tools = tools if tools else None,
            tool_choice = "auto" if tools else None,
            extra_body = {"top_k": top_k, "min_p": min_p, "repetition_penalty" :repetition_penalty,}
        )
        tool_calls = response.choices[0].message.tool_calls or []
        content = response.choices[0].message.content or ""
        tool_calls_dict = [tc.to_dict() for tc in tool_calls] if tool_calls else tool_calls
        messages.append({"role": "assistant", "tool_calls": tool_calls_dict, "content": content,})
        for tool_call in tool_calls:
            fx, args, _id = tool_call.function.name, tool_call.function.arguments, tool_call.id
            out = MAP_FN[fx](**json.loads(args))
            messages.append({"role": "tool", "tool_call_id": _id, "name": fx, "content": str(out),})
        else:
            has_tool_calls = False
    return messages

Après avoir lancé GLM 5.1 via llama-server comme dans GLM-5.1 ou voir Tool Calling Guide pour plus de détails, nous pouvons alors effectuer quelques appels d'outils.

📊 Benchmarks

Vous pouvez voir ci-dessous les benchmarks de GLM-5.1 sous forme de tableau :

Benchmark	GLM-5.1	GLM-5	Qwen3.6-Plus	Minimax M2.7	DeepSeek-V3.2	Kimi K2.5	Claude Opus 4.6	Gemini 3.1 Pro	GPT-5.4
HLE	31.0	30.5	28.8	28.0	25.1	31.5	36.7	45.0	39.8
HLE (avec outils)	52.3	50.4	50.6	-	40.8	51.8	53.1*	51.4*	52.1*
AIME 2026	95.3	95.4	95.1	89.8	95.1	94.5	95.6	98.2	98.7
HMMT Nov. 2025	94.0	96.9	94.6	81.0	90.2	91.1	96.3	94.8	95.8
HMMT Feb. 2026	82.6	82.8	87.8	72.7	79.9	81.3	84.3	87.3	91.8
IMOAnswerBench	83.8	82.5	83.8	66.3	78.3	81.8	75.3	81.0	91.4
GPQA-Diamond	86.2	86.0	90.4	87.0	82.4	87.6	91.3	94.3	92.0
SWE-Bench Pro	58.4	55.1	56.6	56.2	-	53.8	57.3	54.2	57.7
NL2Repo	42.7	35.9	37.9	39.8	-	32.0	49.8	33.4	41.3
Terminal-Bench 2.0 (Terminus-2)	63.5	56.2	61.6	-	39.3	50.8	65.4	68.5	-
Terminal-Bench 2.0 (meilleur score auto-déclaré)	66.5 (Claude Code)	56.2 (Claude Code)	-	57.0 (Claude Code)	46.4 (Claude Code)	-	-	-	75.1 (Codex)
CyberGym	68.7	48.3	-	-	17.3	41.3	66.6	-	-
BrowseComp	68.0	62.0	-	-	51.4	60.6	-	-	-
BrowseComp (avec gestion du contexte)	79.3	75.9	-	-	67.6	74.9	84.0	85.9	82.7
τ³-Bench	70.6	69.2	70.7	67.6	69.2	66.0	72.4	67.1	72.9
MCP-Atlas (ensemble public)	71.8	69.2	74.1	48.8	62.2	63.8	73.8	69.2	67.2
Décathlon d'outils	40.7	38.0	39.8	46.3	35.2	27.8	47.2	48.8	54.6
Vending Bench 2	$5,634.00	$4,432.12	$5,114.87	-	$1,034.00	$1,198.46	$8,017.59	$911.21	$6,144.18