Faire tourner mini-me sur Kronk

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

# Faire tourner mini-me sur Kronk

Ce guide montre comment brancher `mm` sur [Kronk](https://www.kronkai.com), le serveur d'inférence Go d'Ardan Labs, via son point d'accès compatible OpenAI. Il suppose que Kronk est installé (`brew install ardanlabs/kronk/kronk`, ou `go install github.com/ardanlabs/kronk/cmd/kronk@latest`) et que vous savez construire `mm`.

## Étapes

1. Téléchargez le modèle. Kronk charge un modèle installé à la première requête, mais un modèle non installé donne une erreur `model not found` :

   ```bash
   kronk model pull mradermacher/Qwopus3.5-4B-Coder.Q8_0
   ```

2. Lancez le serveur. Il écoute sur `127.0.0.1:11435` :

   ```bash
   kronk server start
   ```

3. Lancez la configuration de démo depuis son répertoire (son `skillsDir` vaut `../../skills`) :

   ```bash
   cd demos/kronk
   ../../mm -config agent.kronk.yaml
   ```

4. Vérifiez la bannière. `provider: kronk` confirme le fournisseur, et `ctx: 131072 (/v1/kronk/models)` est la fenêtre avec laquelle Kronk sert le modèle, lue au démarrage, que le modèle soit chargé ou non.

## Variantes

- **Un autre modèle.** Mettez dans `model:` l'id exactement comme Kronk le liste sur `GET /v1/models` : `provider/modelID`. Kronk refuse un id sans son provider avec `must use provider/modelID`. **L'id du téléchargement n'est pas toujours celui que Kronk sert.** Par exemple Qwen3.5 2B, un modèle plus petit :

  ```bash
  kronk model pull unsloth/Qwen3.5-2B-GGUF:Q4_K_M --local   # --local : serveur arrêté
  curl -s localhost:11435/v1/models                          # le liste comme unsloth/Qwen3.5-2B-Q4_K_M
  ```

  ```yaml
  model: unsloth/Qwen3.5-2B-Q4_K_M    # pas unsloth/Qwen3.5-2B-GGUF:Q4_K_M, qui donne un 404
  ```

  Mesuré sur Kronk 1.33.2 : `ctx: 131072 (/v1/kronk/models)`, et les appels d'outils marchent.
- **Un profil Kronk.** Kronk liste aussi des profils de configuration, `provider/modelID/PROFIL`, par exemple `mradermacher/Qwopus3.5-4B-Coder.Q8_0/AGENT`. Un profil, c'est le même fichier GGUF, servi avec les réglages de cette clé dans `~/.kronk/models/model_config.yaml`. Rien n'est téléchargé deux fois. Les profils `AGENT` viennent du `model_config.yaml` livré avec Kronk ; vous pouvez y ajouter les vôtres, puis relancer Kronk. Celui de Qwopus dit :

  ```yaml
  mradermacher/Qwopus3.5-4B-Coder.Q8_0/AGENT:
    context-window: 65536
    sampling-parameters:
      max_tokens: 8192
      temperature: 1
      top_k: 20
      top_p: 0.95
  ```

  Un profil est un `model:` valide. Ce qu'il change pour `mm` :

  - **La fenêtre : oui.** C'est celle du profil, ici 65536 au lieu des 131072 que Kronk choisit pour le modèle simple. La bannière l'affiche (`ctx: 65536 (/v1/kronk/models)`), et la compaction se déclenche à 75 % de cette fenêtre. Une fenêtre plus petite prend aussi moins de mémoire sur le serveur.
  - **L'échantillonnage : seulement pour les clés que `mm` n'envoie pas.** Une valeur de la requête l'emporte sur celle du profil. Mesuré sur Kronk 1.33.2 : `temperature: 0` dans la requête a donné trois fois de suite la même réponse malgré le `temperature: 1` du profil, et `max_tokens: 5` a coupé la réponse à 5 tokens malgré les 8192 du profil. `mm` envoie toujours `temperature`, `top_p` et `max_tokens` : ses valeurs par défaut, fusionnées avec le `sampling` du fichier (voir [`sampling`](../reference/configuration.md)). Les `temperature`, `top_p` et `max_tokens` du profil ne s'appliquent donc jamais, et ses autres clés seulement quand `sampling` ne les donne pas, ici `top_k: 20`. C'est vrai même pour un fichier sans bloc `sampling:` : `mm` envoie alors `temperature: 0`, `top_p: 0.9`, `max_tokens: 4096` (vérifié dans une trace). Pour avoir les valeurs d'un profil, écrivez-les dans `sampling` ; `mm init` le fait pour vous (ci-dessous).
  - **Le raisonnement : non.** `enable_thinking` et `chat_template_kwargs` dans `sampling` valent aussi par requête.

  `mm init` liste les profils avec une ligne qui dit ce qu'ils sont, et la fenêtre les affiche comme `Qwopus3.5-4B-Coder.Q8…/AGENT`. Quand vous choisissez un profil, `mm init` lit son échantillonnage auprès de Kronk et le recopie dans le `sampling` du fichier. Les valeurs recopiées sont `temperature`, `top_p`, `top_k`, `min_p`, et `max_tokens` quand le profil le plafonne. Elles remplacent celles de la table des familles et du GGUF, chacune marquée `[server] Kronk profile AGENT` :

  ```yaml
  sampling:
    # [server] Kronk profile AGENT (model_config.yaml), read from the server:
    # mm's values replace a profile's, so they are copied here
    temperature: 1.0
    top_p: 0.95
    top_k: 20
    min_p: 0.0
    max_tokens: 8192
  ```
- **Écrire le fichier avec l'assistant.** `mm init --provider kronk` liste les modèles de Kronk et lit auprès de Kronk la fenêtre, l'échantillonnage et le chat template du modèle choisi. Voir [Créer un agent](create-an-agent.md).
- **Laisser mm télécharger le modèle.** Avec `autoPull: true`, mm télécharge au démarrage un modèle que Kronk ne liste pas, via `POST /v1/kronk/models/pull`, et affiche la progression. Voir [`autoPull`](../reference/configuration.md).
- **Depuis une sandbox Docker.** `kronk server start` n'écoute que sur la boucle locale, qu'une sandbox ne peut pas atteindre. Sur l'hôte, lancez-le avec `kronk server start --api-host 0.0.0.0:11435`, et autorisez `localhost:11435` dans la politique réseau de la sandbox. Quand aucun `baseUrl` ne répond, `mm` se replie alors tout seul sur `http://host.docker.internal:11435/v1`.
- **Une fenêtre plus grande ou plus petite.** La fenêtre est celle de Kronk, par modèle : réglez `context-window` pour le modèle dans `~/.kronk/models/model_config.yaml` et relancez Kronk. `mm` lit la nouvelle valeur au démarrage.
- **Un Kronk protégé.** Dans les modes `authenticated` ou `full-protected`, exportez un jeton dans `KRONK_TOKEN` (ou nommez une autre variable dans `apiKeyEnv`). Un jeton refusé donne un avertissement au démarrage qui nomme la variable.
- **Libérer la mémoire.** `/unload` et l'outil `unload_model` déchargent le modèle via `POST /v1/kronk/models/unload`. Voir [Libérer la mémoire d'un modèle](unload-a-model.md).
- **Garder votre propre `agent.yaml`.** `AGENT_PROVIDER=kronk ./mm` marche tant que le fichier laisse `baseUrl` vide.

## Ce qui diffère des autres serveurs

- Pas de ligne `Reading the prompt …` : Kronk n'envoie pas d'avancement pendant qu'il lit, donc `firstTokenTimeout` doit couvrir tout le prompt et le chargement du modèle.
- Le raisonnement se coupe avec `chat_template_kwargs: {enable_thinking: false}`, comme avec llama.cpp ; Kronk ignore `reasoning_effort: none`. Le résumé d'une compaction le fait tout seul. Voir [Couper le raisonnement d'un modèle](turn-reasoning-off.md).

## Voir aussi

- [Fournisseurs : une implémentation par protocole](../explanation/providers.md) — ce qui a été mesuré sur Kronk.
- [Référence de configuration](../reference/configuration.md) — valeurs par défaut des fournisseurs.